@riktajs/core 0.8.0 → 0.10.0

package/dist/core/container/container.js

@@ -1,12 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.container = exports.Container = void 0;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const injection_token_1 = require("./injection-token");
-const registry_1 = require("../registry");
-const abstract_class_utils_1 = require("./abstract-class.utils");
-class Container {
+import 'reflect-metadata';
+import { INJECT_METADATA, AUTOWIRED_METADATA } from '../constants.js';
+import { InjectionToken } from './injection-token.js';
+import { registry } from '../registry.js';
+import { isAbstractClass } from './abstract-class.utils.js';
+import { requestScopeStorage } from './request-scope.js';
+export class Container {
     static instance;
     singletons = new Map();
     providers = new Map();
@@ -79,7 +77,7 @@ class Container {
                     this.singletons.set(token, instance);
                     return instance;
                 }
-                if (!(0, abstract_class_utils_1.isAbstractClass)(token)) {
+                if (!isAbstractClass(token)) {
                     return this.resolveClass(token);
                 }
             }
@@ -97,14 +95,32 @@ class Container {
         throw new Error(`Cannot resolve token: ${this.getTokenName(token)}`);
     }
     resolveAbstractClass(abstractClass, name) {
-        if (name) {
-            return registry_1.registry.resolveImplementation(abstractClass, name);
-        }
         const config = this.providers.get(abstractClass);
         if (config?.provider && 'useClass' in config.provider) {
             return config.provider.useClass;
         }
-        return registry_1.registry.resolveImplementation(abstractClass);
+        const implementations = registry.getImplementations(abstractClass);
+        if (!implementations || implementations.length === 0) {
+            return undefined;
+        }
+        if (name) {
+            const named = implementations.find(i => i.name === name);
+            if (named) {
+                return named.implementation;
+            }
+            throw new Error(`No implementation named '${name}' found for abstract class ${abstractClass.name}. ` +
+                `Available names: ${implementations.filter(i => i.name).map(i => i.name).join(', ') || 'none'}`);
+        }
+        if (implementations.length === 1) {
+            return implementations[0].implementation;
+        }
+        const primary = implementations.find(i => i.isPrimary);
+        if (primary) {
+            return primary.implementation;
+        }
+        const implNames = implementations.map(i => i.implementation.name).join(', ');
+        throw new Error(`Multiple implementations found for abstract class ${abstractClass.name}: ${implNames}. ` +
+            `Use @Primary() to mark one as the default, or @Named() for qualified injection.`);
     }
     resolveProvider(provider, scope) {
         if (typeof provider === 'function') {
@@ -148,9 +164,19 @@ class Container {
         if (scope === 'singleton' && this.singletons.has(target)) {
             return this.singletons.get(target);
         }
+        if (scope === 'request') {
+            if (!requestScopeStorage.isInRequestScope()) {
+                throw new Error(`Cannot resolve request-scoped provider '${target.name}' outside of a request context. ` +
+                    `Request-scoped providers can only be resolved during HTTP request handling.`);
+            }
+            const existingInstance = requestScopeStorage.get(target);
+            if (existingInstance !== undefined) {
+                return existingInstance;
+            }
+        }
         this.resolutionStack.add(target);
         try {
-            const injectMeta = Reflect.getMetadata(constants_1.INJECT_METADATA, target) ?? [];
+            const injectMeta = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
             const paramTypes = Reflect.getMetadata('design:paramtypes', target) ?? [];
             const maxIndex = injectMeta.length > 0
                 ? Math.max(...injectMeta.map(m => m.index ?? -1))
@@ -188,6 +214,9 @@ class Container {
             if (scope === 'singleton') {
                 this.singletons.set(target, instance);
             }
+            else if (scope === 'request') {
+                requestScopeStorage.set(target, instance);
+            }
             return instance;
         }
         finally {
@@ -195,7 +224,7 @@ class Container {
         }
     }
     injectProperties(target, instance) {
-        const autowireMeta = Reflect.getMetadata(constants_1.AUTOWIRED_METADATA, target) ?? [];
+        const autowireMeta = Reflect.getMetadata(AUTOWIRED_METADATA, target) ?? [];
         for (const meta of autowireMeta) {
             if (!meta.propertyKey)
                 continue;
@@ -251,7 +280,7 @@ class Container {
         if (typeof token === 'function') {
             return token.name;
         }
-        if (token instanceof injection_token_1.InjectionToken) {
+        if (token instanceof InjectionToken) {
             return token.toString();
         }
         if (typeof token === 'symbol') {
@@ -260,5 +289,4 @@ class Container {
         return String(token);
     }
 }
-exports.Container = Container;
-exports.container = Container.getInstance();
+export const container = Container.getInstance();

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

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { AnyConstructor } from '../types';
+import { AnyConstructor } from '../types.js';
 export declare function Implements<T extends AnyConstructor>(abstractClass: T): ClassDecorator;
 export declare function Primary(): ClassDecorator;
 export declare function Named(name: string): ClassDecorator;

package/dist/core/container/implements.decorator.js

@@ -1,45 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Implements = Implements;
-exports.Primary = Primary;
-exports.Named = Named;
-exports.AbstractClass = AbstractClass;
-require("reflect-metadata");
-const abstract_class_utils_1 = require("./abstract-class.utils");
-const registry_1 = require("../registry");
-function Implements(abstractClass) {
+import 'reflect-metadata';
+import { setImplementsMetadata, setPrimaryMetadata, markAsAbstract, IMPLEMENTS_METADATA } from './abstract-class.utils.js';
+import { registry } from '../registry.js';
+export function Implements(abstractClass) {
     return (target) => {
-        (0, abstract_class_utils_1.setImplementsMetadata)(target, abstractClass);
-        (0, abstract_class_utils_1.markAsAbstract)(abstractClass);
+        setImplementsMetadata(target, abstractClass);
+        markAsAbstract(abstractClass);
         const name = Reflect.getMetadata('rikta:named', target);
-        registry_1.registry.registerAbstractImplementation(abstractClass, target, name);
+        registry.registerAbstractImplementation(abstractClass, target, name);
         const isPrimary = Reflect.getMetadata('rikta:is-primary', target) === true;
         if (isPrimary) {
-            registry_1.registry.setPrimaryImplementation(abstractClass, target);
+            registry.setPrimaryImplementation(abstractClass, target);
         }
     };
 }
-function Primary() {
+export function Primary() {
     return (target) => {
-        (0, abstract_class_utils_1.setPrimaryMetadata)(target);
-        const abstractClass = Reflect.getMetadata(abstract_class_utils_1.IMPLEMENTS_METADATA, target);
+        setPrimaryMetadata(target);
+        const abstractClass = Reflect.getMetadata(IMPLEMENTS_METADATA, target);
         if (abstractClass) {
-            registry_1.registry.setPrimaryImplementation(abstractClass, target);
+            registry.setPrimaryImplementation(abstractClass, target);
         }
         Reflect.defineMetadata('rikta:is-primary', true, target);
     };
 }
-function Named(name) {
+export function Named(name) {
     return (target) => {
         Reflect.defineMetadata('rikta:named', name, target);
-        const abstractClass = Reflect.getMetadata(abstract_class_utils_1.IMPLEMENTS_METADATA, target);
+        const abstractClass = Reflect.getMetadata(IMPLEMENTS_METADATA, target);
         if (abstractClass) {
-            registry_1.registry.setImplementationName(abstractClass, target, name);
+            registry.setImplementationName(abstractClass, target, name);
         }
     };
 }
-function AbstractClass() {
+export function AbstractClass() {
     return (target) => {
-        (0, abstract_class_utils_1.markAsAbstract)(target);
+        markAsAbstract(target);
     };
 }

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

@@ -1,4 +1,5 @@
-export * from './container';
-export * from './injection-token';
-export * from './abstract-class.utils';
-export * from './implements.decorator';
+export * from './container.js';
+export * from './injection-token.js';
+export * from './abstract-class.utils.js';
+export * from './implements.decorator.js';
+export * from './request-scope.js';

package/dist/core/container/index.js

@@ -1,20 +1,5 @@
-"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("./container"), exports);
-__exportStar(require("./injection-token"), exports);
-__exportStar(require("./abstract-class.utils"), exports);
-__exportStar(require("./implements.decorator"), exports);
+export * from './container.js';
+export * from './injection-token.js';
+export * from './abstract-class.utils.js';
+export * from './implements.decorator.js';
+export * from './request-scope.js';

package/dist/core/container/injection-token.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectionToken = void 0;
-class InjectionToken {
+export class InjectionToken {
     description;
     options;
     constructor(description, options) {
@@ -12,4 +9,3 @@ class InjectionToken {
         return `InjectionToken(${this.description})`;
     }
 }
-exports.InjectionToken = InjectionToken;

package/dist/core/container/request-scope.d.ts

@@ -0,0 +1,16 @@
+import { Token } from './injection-token.js';
+export declare class RequestScopeStorage {
+    private static instance;
+    private readonly asyncLocalStorage;
+    private constructor();
+    static getInstance(): RequestScopeStorage;
+    static reset(): void;
+    run<T>(fn: () => T): T;
+    runAsync<T>(fn: () => Promise<T>): Promise<T>;
+    isInRequestScope(): boolean;
+    get<T>(token: Token<T>): T | undefined;
+    set<T>(token: Token<T>, instance: T): void;
+    has(token: Token): boolean;
+    getStore(): Map<Token, unknown> | undefined;
+}
+export declare const requestScopeStorage: RequestScopeStorage;

package/dist/core/container/request-scope.js

@@ -0,0 +1,49 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export class RequestScopeStorage {
+    static instance;
+    asyncLocalStorage = new AsyncLocalStorage();
+    constructor() { }
+    static getInstance() {
+        if (!RequestScopeStorage.instance) {
+            RequestScopeStorage.instance = new RequestScopeStorage();
+        }
+        return RequestScopeStorage.instance;
+    }
+    static reset() {
+        RequestScopeStorage.instance = new RequestScopeStorage();
+    }
+    run(fn) {
+        const store = new Map();
+        return this.asyncLocalStorage.run(store, fn);
+    }
+    async runAsync(fn) {
+        const store = new Map();
+        return this.asyncLocalStorage.run(store, fn);
+    }
+    isInRequestScope() {
+        return this.asyncLocalStorage.getStore() !== undefined;
+    }
+    get(token) {
+        const store = this.asyncLocalStorage.getStore();
+        if (!store) {
+            return undefined;
+        }
+        return store.get(token);
+    }
+    set(token, instance) {
+        const store = this.asyncLocalStorage.getStore();
+        if (!store) {
+            throw new Error('Cannot set request-scoped instance outside of a request context. ' +
+                'Make sure RequestScopeStorage.run() or runAsync() is being used.');
+        }
+        store.set(token, instance);
+    }
+    has(token) {
+        const store = this.asyncLocalStorage.getStore();
+        return store?.has(token) ?? false;
+    }
+    getStore() {
+        return this.asyncLocalStorage.getStore();
+    }
+}
+export const requestScopeStorage = RequestScopeStorage.getInstance();

package/dist/core/decorators/apply-decorators.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyDecorators = applyDecorators;
-exports.SetMetadata = SetMetadata;
-require("reflect-metadata");
-function applyDecorators(...decorators) {
+import 'reflect-metadata';
+export function applyDecorators(...decorators) {
     return ((target, propertyKey, descriptor) => {
         for (const decorator of decorators.reverse()) {
             if (descriptor) {
@@ -27,7 +23,7 @@ function applyDecorators(...decorators) {
         }
     });
 }
-function SetMetadata(key, value) {
+export function SetMetadata(key, value) {
     const decoratorFactory = (target, propertyKey, descriptor) => {
         if (descriptor) {
             Reflect.defineMetadata(key, value, target.constructor, propertyKey);

package/dist/core/decorators/autowired.decorator.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Token } from '../container/injection-token';
+import { Token } from '../container/injection-token.js';
 export interface AutowiredMetadata {
     token: Token;
     index?: number;

package/dist/core/decorators/autowired.decorator.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Autowired = Autowired;
-exports.Optional = Optional;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-function Autowired(token, name) {
+import 'reflect-metadata';
+import { INJECT_METADATA, AUTOWIRED_METADATA } from '../constants.js';
+export function Autowired(token, name) {
     return (target, propertyKey, parameterIndex) => {
         if (typeof parameterIndex === 'number') {
             const paramTypes = Reflect.getMetadata('design:paramtypes', target) ?? [];
@@ -14,13 +10,13 @@ function Autowired(token, name) {
                 throw new Error(`@Autowired() on constructor parameter ${parameterIndex} of ${target.name} ` +
                     `could not infer type. Please provide a token explicitly.`);
             }
-            const existingInjects = Reflect.getMetadata(constants_1.INJECT_METADATA, target) ?? [];
+            const existingInjects = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
             existingInjects.push({
                 token: resolvedToken,
                 index: parameterIndex,
                 name,
             });
-            Reflect.defineMetadata(constants_1.INJECT_METADATA, existingInjects, target);
+            Reflect.defineMetadata(INJECT_METADATA, existingInjects, target);
         }
         else if (propertyKey !== undefined) {
             const inferredType = Reflect.getMetadata('design:type', target, propertyKey);
@@ -29,20 +25,20 @@ function Autowired(token, name) {
                 throw new Error(`@Autowired() on ${target.constructor.name}.${String(propertyKey)} ` +
                     `could not infer type. Please provide a token explicitly.`);
             }
-            const existingAutowires = Reflect.getMetadata(constants_1.AUTOWIRED_METADATA, target.constructor) ?? [];
+            const existingAutowires = Reflect.getMetadata(AUTOWIRED_METADATA, target.constructor) ?? [];
             existingAutowires.push({
                 token: resolvedToken,
                 propertyKey: String(propertyKey),
                 name,
             });
-            Reflect.defineMetadata(constants_1.AUTOWIRED_METADATA, existingAutowires, target.constructor);
+            Reflect.defineMetadata(AUTOWIRED_METADATA, existingAutowires, target.constructor);
         }
     };
 }
-function Optional() {
+export function Optional() {
     return (target, propertyKey, parameterIndex) => {
         if (typeof parameterIndex === 'number') {
-            const existingInjects = Reflect.getMetadata(constants_1.INJECT_METADATA, target) ?? [];
+            const existingInjects = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
             let meta = existingInjects.find(m => m.index === parameterIndex);
             if (meta) {
                 meta.optional = true;
@@ -58,10 +54,10 @@ function Optional() {
                     });
                 }
             }
-            Reflect.defineMetadata(constants_1.INJECT_METADATA, existingInjects, target);
+            Reflect.defineMetadata(INJECT_METADATA, existingInjects, target);
         }
         else if (propertyKey !== undefined) {
-            const existingAutowires = Reflect.getMetadata(constants_1.AUTOWIRED_METADATA, target.constructor) ?? [];
+            const existingAutowires = Reflect.getMetadata(AUTOWIRED_METADATA, target.constructor) ?? [];
             let meta = existingAutowires.find(m => m.propertyKey === String(propertyKey));
             if (meta) {
                 meta.optional = true;
@@ -76,7 +72,7 @@ function Optional() {
                     });
                 }
             }
-            Reflect.defineMetadata(constants_1.AUTOWIRED_METADATA, existingAutowires, target.constructor);
+            Reflect.defineMetadata(AUTOWIRED_METADATA, existingAutowires, target.constructor);
         }
     };
 }

package/dist/core/decorators/config-property.decorator.js

@@ -1,11 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigProperty = ConfigProperty;
-exports.getConfigPropertyMappings = getConfigPropertyMappings;
-exports.hasConfigProperties = hasConfigProperties;
-exports.clearPropertyNameCache = clearPropertyNameCache;
-require("reflect-metadata");
-const constants_1 = require("../constants");
+import 'reflect-metadata';
+import { CONFIG_PROPERTY_METADATA } from '../constants.js';
 const propertyNameCache = new Map();
 function toUpperSnakeCase(propertyName) {
     if (propertyNameCache.has(propertyName)) {
@@ -18,7 +12,7 @@ function toUpperSnakeCase(propertyName) {
     propertyNameCache.set(propertyName, envKey);
     return envKey;
 }
-function ConfigProperty(envKey) {
+export function ConfigProperty(envKey) {
     return (target, propertyKey) => {
         if (typeof propertyKey === 'symbol') {
             throw new Error(`@ConfigProperty: Symbol properties are not supported. ` +
@@ -34,7 +28,7 @@ function ConfigProperty(envKey) {
                 `Use "${finalEnvKey.toUpperCase()}" instead.`);
         }
         const constructor = target.constructor;
-        const existingMappings = Reflect.getMetadata(constants_1.CONFIG_PROPERTY_METADATA, constructor) || [];
+        const existingMappings = Reflect.getMetadata(CONFIG_PROPERTY_METADATA, constructor) || [];
         const duplicate = existingMappings.find(m => m.propertyKey === propertyKey);
         if (duplicate) {
             throw new Error(`@ConfigProperty: Property "${propertyKey}" on class "${constructor.name}" ` +
@@ -50,16 +44,16 @@ function ConfigProperty(envKey) {
             envKey: finalEnvKey,
         };
         const updatedMappings = [...existingMappings, newMapping];
-        Reflect.defineMetadata(constants_1.CONFIG_PROPERTY_METADATA, updatedMappings, constructor);
+        Reflect.defineMetadata(CONFIG_PROPERTY_METADATA, updatedMappings, constructor);
     };
 }
-function getConfigPropertyMappings(target) {
-    return Reflect.getMetadata(constants_1.CONFIG_PROPERTY_METADATA, target) || [];
+export function getConfigPropertyMappings(target) {
+    return Reflect.getMetadata(CONFIG_PROPERTY_METADATA, target) || [];
 }
-function hasConfigProperties(target) {
+export function hasConfigProperties(target) {
     const mappings = getConfigPropertyMappings(target);
     return mappings.length > 0;
 }
-function clearPropertyNameCache() {
+export function clearPropertyNameCache() {
     propertyNameCache.clear();
 }

package/dist/core/decorators/controller.decorator.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controller = Controller;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const container_1 = require("../container/container");
-const registry_1 = require("../registry");
-function Controller(prefixOrOptions) {
+import 'reflect-metadata';
+import { CONTROLLER_METADATA, INJECTABLE_METADATA } from '../constants.js';
+import { container } from '../container/container.js';
+import { registry } from '../registry.js';
+export function Controller(prefixOrOptions) {
     return (target) => {
         const prefix = typeof prefixOrOptions === 'string'
             ? prefixOrOptions
@@ -13,9 +10,9 @@ function Controller(prefixOrOptions) {
         const normalizedPrefix = prefix
             ? (prefix.startsWith('/') ? prefix : `/${prefix}`)
             : '';
-        Reflect.defineMetadata(constants_1.CONTROLLER_METADATA, { prefix: normalizedPrefix }, target);
-        Reflect.defineMetadata(constants_1.INJECTABLE_METADATA, { scope: 'singleton' }, target);
-        container_1.container.register(target, { scope: 'singleton' });
-        registry_1.registry.registerController(target);
+        Reflect.defineMetadata(CONTROLLER_METADATA, { prefix: normalizedPrefix }, target);
+        Reflect.defineMetadata(INJECTABLE_METADATA, { scope: 'singleton' }, target);
+        container.register(target, { scope: 'singleton' });
+        registry.registerController(target);
     };
 }

package/dist/core/decorators/create-param-decorator.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { ExecutionContext } from '../guards/execution-context';
+import { ExecutionContext } from '../guards/execution-context.js';
 export declare const CUSTOM_PARAM_METADATA: unique symbol;
 export interface CustomParamMetadata<T = unknown> {
     index: number;

package/dist/core/decorators/create-param-decorator.js

@@ -1,26 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CUSTOM_PARAM_METADATA = void 0;
-exports.createParamDecorator = createParamDecorator;
-exports.getCustomParamMetadata = getCustomParamMetadata;
-require("reflect-metadata");
-exports.CUSTOM_PARAM_METADATA = Symbol.for('rikta:custom:param:metadata');
-function createParamDecorator(factory) {
+import 'reflect-metadata';
+export const CUSTOM_PARAM_METADATA = Symbol.for('rikta:custom:param:metadata');
+export function createParamDecorator(factory) {
     return (data) => {
         return (target, propertyKey, parameterIndex) => {
             if (propertyKey === undefined)
                 return;
-            const existingParams = Reflect.getMetadata(exports.CUSTOM_PARAM_METADATA, target.constructor, propertyKey) ?? [];
+            const existingParams = Reflect.getMetadata(CUSTOM_PARAM_METADATA, target.constructor, propertyKey) ?? [];
             const metadata = {
                 index: parameterIndex,
                 factory: factory,
                 data,
             };
             existingParams.push(metadata);
-            Reflect.defineMetadata(exports.CUSTOM_PARAM_METADATA, existingParams, target.constructor, propertyKey);
+            Reflect.defineMetadata(CUSTOM_PARAM_METADATA, existingParams, target.constructor, propertyKey);
         };
     };
 }
-function getCustomParamMetadata(target, propertyKey) {
-    return Reflect.getMetadata(exports.CUSTOM_PARAM_METADATA, target, propertyKey) ?? [];
+export function getCustomParamMetadata(target, propertyKey) {
+    return Reflect.getMetadata(CUSTOM_PARAM_METADATA, target, propertyKey) ?? [];
 }

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

@@ -1,9 +1,9 @@
-export * from './injectable.decorator';
-export * from './controller.decorator';
-export * from './route.decorator';
-export * from './param.decorator';
-export * from './autowired.decorator';
-export * from './provider.decorator';
-export * from './config-property.decorator';
-export * from './create-param-decorator';
-export * from './apply-decorators';
+export * from './injectable.decorator.js';
+export * from './controller.decorator.js';
+export * from './route.decorator.js';
+export * from './param.decorator.js';
+export * from './autowired.decorator.js';
+export * from './provider.decorator.js';
+export * from './config-property.decorator.js';
+export * from './create-param-decorator.js';
+export * from './apply-decorators.js';

package/dist/core/decorators/index.js

@@ -1,25 +1,9 @@
-"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("./injectable.decorator"), exports);
-__exportStar(require("./controller.decorator"), exports);
-__exportStar(require("./route.decorator"), exports);
-__exportStar(require("./param.decorator"), exports);
-__exportStar(require("./autowired.decorator"), exports);
-__exportStar(require("./provider.decorator"), exports);
-__exportStar(require("./config-property.decorator"), exports);
-__exportStar(require("./create-param-decorator"), exports);
-__exportStar(require("./apply-decorators"), exports);
+export * from './injectable.decorator.js';
+export * from './controller.decorator.js';
+export * from './route.decorator.js';
+export * from './param.decorator.js';
+export * from './autowired.decorator.js';
+export * from './provider.decorator.js';
+export * from './config-property.decorator.js';
+export * from './create-param-decorator.js';
+export * from './apply-decorators.js';

package/dist/core/decorators/injectable.decorator.d.ts

@@ -1,3 +1,3 @@
 import 'reflect-metadata';
-import { InjectableOptions } from '../types';
+import { InjectableOptions } from '../types.js';
 export declare function Injectable(options?: InjectableOptions): ClassDecorator;

package/dist/core/decorators/injectable.decorator.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injectable = Injectable;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const container_1 = require("../container/container");
-const registry_1 = require("../registry");
-function Injectable(options = {}) {
+import 'reflect-metadata';
+import { INJECTABLE_METADATA } from '../constants.js';
+import { container } from '../container/container.js';
+import { registry } from '../registry.js';
+export function Injectable(options = {}) {
     return (target) => {
-        Reflect.defineMetadata(constants_1.INJECTABLE_METADATA, options, target);
-        container_1.container.register(target, options);
-        registry_1.registry.registerProvider(target);
+        Reflect.defineMetadata(INJECTABLE_METADATA, options, target);
+        container.register(target, options);
+        registry.registerProvider(target);
     };
 }

package/dist/core/decorators/param.decorator.d.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import type { ZodType } from 'zod';
-import { ParamType } from '../constants';
+import { ParamType } from '../constants.js';
 export interface ParamMetadata {
     index: number;
     type: ParamType;