@riktajs/core 0.10.2 → 0.10.3

package/dist/core/container/container.js

@@ -1,292 +0,0 @@
-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();
-    resolutionStack = new Set();
-    constructor() { }
-    static getInstance() {
-        if (!Container.instance) {
-            Container.instance = new Container();
-        }
-        return Container.instance;
-    }
-    static reset() {
-        Container.instance = new Container();
-    }
-    register(target, options = {}) {
-        const scope = options.scope ?? 'singleton';
-        this.providers.set(target, { scope });
-    }
-    registerProvider(provider) {
-        if (typeof provider === 'function') {
-            this.register(provider);
-            return;
-        }
-        const token = provider.provide;
-        if ('useValue' in provider) {
-            this.providers.set(token, { scope: 'singleton', provider });
-            this.singletons.set(token, provider.useValue);
-        }
-        else if ('useFactory' in provider) {
-            this.providers.set(token, { scope: 'singleton', provider });
-        }
-        else if ('useClass' in provider) {
-            this.providers.set(token, { scope: 'singleton', provider });
-        }
-        else if ('useExisting' in provider) {
-            this.providers.set(token, { scope: 'singleton', provider });
-        }
-    }
-    registerValue(token, value) {
-        this.registerProvider({ provide: token, useValue: value });
-    }
-    registerFactory(token, factory, inject) {
-        this.registerProvider({ provide: token, useFactory: factory, inject });
-    }
-    has(token) {
-        return this.providers.has(token);
-    }
-    resolve(token) {
-        return this.resolveToken(token, false);
-    }
-    resolveOptional(token) {
-        return this.resolveToken(token, true);
-    }
-    resolveToken(token, optional) {
-        if (this.resolutionStack.has(token)) {
-            const chain = [...this.resolutionStack]
-                .map(t => this.getTokenName(t))
-                .join(' -> ');
-            throw new Error(`Circular dependency detected: ${chain} -> ${this.getTokenName(token)}`);
-        }
-        if (this.singletons.has(token)) {
-            return this.singletons.get(token);
-        }
-        const config = this.providers.get(token);
-        if (!config) {
-            if (typeof token === 'function') {
-                const implementation = this.resolveAbstractClass(token);
-                if (implementation) {
-                    const instance = this.resolveClass(implementation);
-                    this.singletons.set(token, instance);
-                    return instance;
-                }
-                if (!isAbstractClass(token)) {
-                    return this.resolveClass(token);
-                }
-            }
-            if (optional) {
-                return undefined;
-            }
-            throw new Error(`No provider found for token: ${this.getTokenName(token)}`);
-        }
-        if (config.provider && typeof config.provider !== 'function') {
-            return this.resolveProvider(config.provider, config.scope);
-        }
-        if (typeof token === 'function') {
-            return this.resolveClass(token);
-        }
-        throw new Error(`Cannot resolve token: ${this.getTokenName(token)}`);
-    }
-    resolveAbstractClass(abstractClass, name) {
-        const config = this.providers.get(abstractClass);
-        if (config?.provider && 'useClass' in config.provider) {
-            return config.provider.useClass;
-        }
-        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') {
-            return this.resolveClass(provider);
-        }
-        const token = provider.provide;
-        if ('useValue' in provider) {
-            return provider.useValue;
-        }
-        if ('useFactory' in provider) {
-            const factoryProvider = provider;
-            const deps = (factoryProvider.inject ?? []).map(dep => this.resolve(dep));
-            const result = factoryProvider.useFactory(...deps);
-            if (scope === 'singleton') {
-                this.singletons.set(token, result);
-            }
-            return result;
-        }
-        if ('useClass' in provider) {
-            const classProvider = provider;
-            const instance = this.resolveClass(classProvider.useClass);
-            if (scope === 'singleton') {
-                this.singletons.set(token, instance);
-            }
-            return instance;
-        }
-        if ('useExisting' in provider) {
-            return this.resolve(provider.useExisting);
-        }
-        throw new Error('Invalid provider configuration');
-    }
-    resolveClass(target) {
-        if (this.resolutionStack.has(target)) {
-            const chain = [...this.resolutionStack, target]
-                .map(t => this.getTokenName(t))
-                .join(' -> ');
-            throw new Error(`Circular dependency detected: ${chain}`);
-        }
-        const providerConfig = this.providers.get(target);
-        const scope = providerConfig?.scope ?? 'singleton';
-        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(INJECT_METADATA, target) ?? [];
-            const paramTypes = Reflect.getMetadata('design:paramtypes', target) ?? [];
-            const maxIndex = injectMeta.length > 0
-                ? Math.max(...injectMeta.map(m => m.index ?? -1))
-                : -1;
-            const paramCount = Math.max(paramTypes.length, maxIndex + 1);
-            const dependencies = [];
-            for (let index = 0; index < paramCount; index++) {
-                const paramType = paramTypes[index];
-                const injectOverride = injectMeta.find(m => m.index === index);
-                const token = injectOverride?.token ?? paramType;
-                const isOptional = injectOverride?.optional ?? false;
-                const name = injectOverride?.name;
-                if (!token) {
-                    if (isOptional) {
-                        dependencies.push(undefined);
-                        continue;
-                    }
-                    throw new Error(`Cannot resolve constructor parameter ${index} of ${target.name}. ` +
-                        `Use @Autowired(token) decorator.`);
-                }
-                if (!injectOverride && this.isPrimitive(paramType)) {
-                    if (isOptional) {
-                        dependencies.push(undefined);
-                        continue;
-                    }
-                    throw new Error(`Cannot inject primitive type '${paramType?.name ?? 'unknown'}' into ${target.name}. ` +
-                        `Use @Autowired(token) decorator.`);
-                }
-                dependencies.push(isOptional
-                    ? this.resolveWithNameOptional(token, name)
-                    : this.resolveWithName(token, name));
-            }
-            const instance = new target(...dependencies);
-            this.injectProperties(target, instance);
-            if (scope === 'singleton') {
-                this.singletons.set(target, instance);
-            }
-            else if (scope === 'request') {
-                requestScopeStorage.set(target, instance);
-            }
-            return instance;
-        }
-        finally {
-            this.resolutionStack.delete(target);
-        }
-    }
-    injectProperties(target, instance) {
-        const autowireMeta = Reflect.getMetadata(AUTOWIRED_METADATA, target) ?? [];
-        for (const meta of autowireMeta) {
-            if (!meta.propertyKey)
-                continue;
-            const isOptional = meta.optional ?? false;
-            try {
-                const value = isOptional
-                    ? this.resolveWithNameOptional(meta.token, meta.name)
-                    : this.resolveWithName(meta.token, meta.name);
-                instance[meta.propertyKey] = value;
-            }
-            catch (error) {
-                if (!isOptional) {
-                    throw error;
-                }
-            }
-        }
-    }
-    resolveWithName(token, name) {
-        if (name && typeof token === 'function') {
-            const implementation = this.resolveAbstractClass(token, name);
-            if (implementation) {
-                return this.resolveClass(implementation);
-            }
-            throw new Error(`No implementation named '${name}' found for ${this.getTokenName(token)}`);
-        }
-        return this.resolve(token);
-    }
-    resolveWithNameOptional(token, name) {
-        try {
-            return this.resolveWithName(token, name);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    registerInstance(target, instance) {
-        this.providers.set(target, { scope: 'singleton' });
-        this.singletons.set(target, instance);
-    }
-    getProviders() {
-        return [...this.providers.keys()];
-    }
-    clearSingletons() {
-        this.singletons.clear();
-    }
-    isPrimitive(type) {
-        if (!type)
-            return true;
-        const primitives = [String, Number, Boolean, Object, Array, Function];
-        return primitives.includes(type);
-    }
-    getTokenName(token) {
-        if (typeof token === 'function') {
-            return token.name;
-        }
-        if (token instanceof InjectionToken) {
-            return token.toString();
-        }
-        if (typeof token === 'symbol') {
-            return token.toString();
-        }
-        return String(token);
-    }
-}
-export const container = Container.getInstance();

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

@@ -1,6 +0,0 @@
-import 'reflect-metadata';
-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;
-export declare function AbstractClass(): ClassDecorator;

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

@@ -1,39 +0,0 @@
-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) => {
-        setImplementsMetadata(target, abstractClass);
-        markAsAbstract(abstractClass);
-        const name = Reflect.getMetadata('rikta:named', target);
-        registry.registerAbstractImplementation(abstractClass, target, name);
-        const isPrimary = Reflect.getMetadata('rikta:is-primary', target) === true;
-        if (isPrimary) {
-            registry.setPrimaryImplementation(abstractClass, target);
-        }
-    };
-}
-export function Primary() {
-    return (target) => {
-        setPrimaryMetadata(target);
-        const abstractClass = Reflect.getMetadata(IMPLEMENTS_METADATA, target);
-        if (abstractClass) {
-            registry.setPrimaryImplementation(abstractClass, target);
-        }
-        Reflect.defineMetadata('rikta:is-primary', true, target);
-    };
-}
-export function Named(name) {
-    return (target) => {
-        Reflect.defineMetadata('rikta:named', name, target);
-        const abstractClass = Reflect.getMetadata(IMPLEMENTS_METADATA, target);
-        if (abstractClass) {
-            registry.setImplementationName(abstractClass, target, name);
-        }
-    };
-}
-export function AbstractClass() {
-    return (target) => {
-        markAsAbstract(target);
-    };
-}

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

@@ -1,5 +0,0 @@
-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,5 +0,0 @@
-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.d.ts

@@ -1,29 +0,0 @@
-export declare class InjectionToken<T = unknown> {
-    readonly description: string;
-    readonly options?: {
-        factory?: () => T;
-    } | undefined;
-    constructor(description: string, options?: {
-        factory?: () => T;
-    } | undefined);
-    toString(): string;
-}
-export type Token<T = unknown> = (new (...args: unknown[]) => T) | InjectionToken<T> | string | symbol;
-export interface ClassProvider<T = unknown> {
-    provide: Token<T>;
-    useClass: new (...args: unknown[]) => T;
-}
-export interface ValueProvider<T = unknown> {
-    provide: Token<T>;
-    useValue: T;
-}
-export interface FactoryProvider<T = unknown> {
-    provide: Token<T>;
-    useFactory: (...args: unknown[]) => T | Promise<T>;
-    inject?: Token[];
-}
-export interface ExistingProvider<T = unknown> {
-    provide: Token<T>;
-    useExisting: Token<T>;
-}
-export type ProviderDefinition<T = unknown> = ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T> | (new (...args: unknown[]) => T);

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

@@ -1,11 +0,0 @@
-export class InjectionToken {
-    description;
-    options;
-    constructor(description, options) {
-        this.description = description;
-        this.options = options;
-    }
-    toString() {
-        return `InjectionToken(${this.description})`;
-    }
-}

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

@@ -1,16 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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.d.ts

@@ -1,8 +0,0 @@
-import 'reflect-metadata';
-type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction | void;
-type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
-type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;
-type AnyDecorator = ClassDecorator | MethodDecorator | PropertyDecorator;
-export declare function applyDecorators(...decorators: AnyDecorator[]): MethodDecorator & ClassDecorator & PropertyDecorator;
-export declare function SetMetadata<T = unknown>(key: string | symbol, value: T): MethodDecorator & ClassDecorator;
-export {};

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

@@ -1,36 +0,0 @@
-import 'reflect-metadata';
-export function applyDecorators(...decorators) {
-    return ((target, propertyKey, descriptor) => {
-        for (const decorator of decorators.reverse()) {
-            if (descriptor) {
-                const result = decorator(target, propertyKey, descriptor);
-                if (result) {
-                    descriptor = result;
-                }
-            }
-            else if (propertyKey !== undefined) {
-                decorator(target, propertyKey);
-            }
-            else {
-                const result = decorator(target);
-                if (result) {
-                    return result;
-                }
-            }
-        }
-        if (descriptor) {
-            return descriptor;
-        }
-    });
-}
-export function SetMetadata(key, value) {
-    const decoratorFactory = (target, propertyKey, descriptor) => {
-        if (descriptor) {
-            Reflect.defineMetadata(key, value, target.constructor, propertyKey);
-        }
-        else {
-            Reflect.defineMetadata(key, value, target);
-        }
-    };
-    return decoratorFactory;
-}

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

@@ -1,11 +0,0 @@
-import 'reflect-metadata';
-import { Token } from '../container/injection-token.js';
-export interface AutowiredMetadata {
-    token: Token;
-    index?: number;
-    propertyKey?: string;
-    optional?: boolean;
-    name?: string;
-}
-export declare function Autowired(token?: Token, name?: string): ParameterDecorator & PropertyDecorator;
-export declare function Optional(): ParameterDecorator & PropertyDecorator;

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

@@ -1,78 +0,0 @@
-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) ?? [];
-            const inferredType = paramTypes[parameterIndex];
-            const resolvedToken = token ?? inferredType;
-            if (!resolvedToken) {
-                throw new Error(`@Autowired() on constructor parameter ${parameterIndex} of ${target.name} ` +
-                    `could not infer type. Please provide a token explicitly.`);
-            }
-            const existingInjects = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
-            existingInjects.push({
-                token: resolvedToken,
-                index: parameterIndex,
-                name,
-            });
-            Reflect.defineMetadata(INJECT_METADATA, existingInjects, target);
-        }
-        else if (propertyKey !== undefined) {
-            const inferredType = Reflect.getMetadata('design:type', target, propertyKey);
-            const resolvedToken = token ?? inferredType;
-            if (!resolvedToken) {
-                throw new Error(`@Autowired() on ${target.constructor.name}.${String(propertyKey)} ` +
-                    `could not infer type. Please provide a token explicitly.`);
-            }
-            const existingAutowires = Reflect.getMetadata(AUTOWIRED_METADATA, target.constructor) ?? [];
-            existingAutowires.push({
-                token: resolvedToken,
-                propertyKey: String(propertyKey),
-                name,
-            });
-            Reflect.defineMetadata(AUTOWIRED_METADATA, existingAutowires, target.constructor);
-        }
-    };
-}
-export function Optional() {
-    return (target, propertyKey, parameterIndex) => {
-        if (typeof parameterIndex === 'number') {
-            const existingInjects = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
-            let meta = existingInjects.find(m => m.index === parameterIndex);
-            if (meta) {
-                meta.optional = true;
-            }
-            else {
-                const paramTypes = Reflect.getMetadata('design:paramtypes', target) ?? [];
-                const paramType = paramTypes[parameterIndex];
-                if (paramType) {
-                    existingInjects.push({
-                        token: paramType,
-                        index: parameterIndex,
-                        optional: true,
-                    });
-                }
-            }
-            Reflect.defineMetadata(INJECT_METADATA, existingInjects, target);
-        }
-        else if (propertyKey !== undefined) {
-            const existingAutowires = Reflect.getMetadata(AUTOWIRED_METADATA, target.constructor) ?? [];
-            let meta = existingAutowires.find(m => m.propertyKey === String(propertyKey));
-            if (meta) {
-                meta.optional = true;
-            }
-            else {
-                const propType = Reflect.getMetadata('design:type', target, propertyKey);
-                if (propType) {
-                    existingAutowires.push({
-                        token: propType,
-                        propertyKey: String(propertyKey),
-                        optional: true,
-                    });
-                }
-            }
-            Reflect.defineMetadata(AUTOWIRED_METADATA, existingAutowires, target.constructor);
-        }
-    };
-}

package/dist/core/decorators/config-property.decorator.d.ts

@@ -1,9 +0,0 @@
-import 'reflect-metadata';
-export interface ConfigPropertyMapping {
-    propertyKey: string;
-    envKey: string;
-}
-export declare function ConfigProperty(envKey?: string): PropertyDecorator;
-export declare function getConfigPropertyMappings(target: Function): ConfigPropertyMapping[];
-export declare function hasConfigProperties(target: Function): boolean;
-export declare function clearPropertyNameCache(): void;

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

@@ -1,59 +0,0 @@
-import 'reflect-metadata';
-import { CONFIG_PROPERTY_METADATA } from '../constants.js';
-const propertyNameCache = new Map();
-function toUpperSnakeCase(propertyName) {
-    if (propertyNameCache.has(propertyName)) {
-        return propertyNameCache.get(propertyName);
-    }
-    const envKey = propertyName
-        .replace(/([A-Z])/g, '_$1')
-        .toUpperCase()
-        .replace(/^_/, '');
-    propertyNameCache.set(propertyName, envKey);
-    return envKey;
-}
-export function ConfigProperty(envKey) {
-    return (target, propertyKey) => {
-        if (typeof propertyKey === 'symbol') {
-            throw new Error(`@ConfigProperty: Symbol properties are not supported. ` +
-                `Property "${String(propertyKey)}" must be a string.`);
-        }
-        const finalEnvKey = envKey ?? toUpperSnakeCase(propertyKey);
-        if (!finalEnvKey || typeof finalEnvKey !== 'string') {
-            throw new Error(`@ConfigProperty: Invalid env key for property "${propertyKey}". ` +
-                `Env key must be a non-empty string.`);
-        }
-        if (finalEnvKey !== finalEnvKey.toUpperCase()) {
-            throw new Error(`@ConfigProperty: Env key "${finalEnvKey}" for property "${propertyKey}" must be UPPERCASE. ` +
-                `Use "${finalEnvKey.toUpperCase()}" instead.`);
-        }
-        const constructor = target.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}" ` +
-                `is already decorated. Remove the duplicate @ConfigProperty decorator.`);
-        }
-        const duplicateEnvKey = existingMappings.find(m => m.envKey === finalEnvKey);
-        if (duplicateEnvKey) {
-            throw new Error(`@ConfigProperty: Env key "${finalEnvKey}" is already mapped to property "${duplicateEnvKey.propertyKey}" ` +
-                `on class "${constructor.name}". Each env key can only be mapped to one property.`);
-        }
-        const newMapping = {
-            propertyKey,
-            envKey: finalEnvKey,
-        };
-        const updatedMappings = [...existingMappings, newMapping];
-        Reflect.defineMetadata(CONFIG_PROPERTY_METADATA, updatedMappings, constructor);
-    };
-}
-export function getConfigPropertyMappings(target) {
-    return Reflect.getMetadata(CONFIG_PROPERTY_METADATA, target) || [];
-}
-export function hasConfigProperties(target) {
-    const mappings = getConfigPropertyMappings(target);
-    return mappings.length > 0;
-}
-export function clearPropertyNameCache() {
-    propertyNameCache.clear();
-}

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

@@ -1,5 +0,0 @@
-import 'reflect-metadata';
-export interface ControllerOptions {
-    prefix?: string;
-}
-export declare function Controller(prefixOrOptions?: string | ControllerOptions): ClassDecorator;