@carno.js/core 0.2.3

package/dist/commons/http-code.enum.d.ts

@@ -0,0 +1,50 @@
+export declare enum HttpCode {
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLY_HINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    MISDIRECTED = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    FAILED_DEPENDENCY = 424,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}

package/dist/commons/http-code.enum.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCode = void 0;
+var HttpCode;
+(function (HttpCode) {
+    HttpCode[HttpCode["CONTINUE"] = 100] = "CONTINUE";
+    HttpCode[HttpCode["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HttpCode[HttpCode["PROCESSING"] = 102] = "PROCESSING";
+    HttpCode[HttpCode["EARLY_HINTS"] = 103] = "EARLY_HINTS";
+    HttpCode[HttpCode["OK"] = 200] = "OK";
+    HttpCode[HttpCode["CREATED"] = 201] = "CREATED";
+    HttpCode[HttpCode["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpCode[HttpCode["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    HttpCode[HttpCode["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpCode[HttpCode["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpCode[HttpCode["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HttpCode[HttpCode["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+    HttpCode[HttpCode["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpCode[HttpCode["FOUND"] = 302] = "FOUND";
+    HttpCode[HttpCode["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HttpCode[HttpCode["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HttpCode[HttpCode["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpCode[HttpCode["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpCode[HttpCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpCode[HttpCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpCode[HttpCode["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HttpCode[HttpCode["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpCode[HttpCode["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpCode[HttpCode["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpCode[HttpCode["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpCode[HttpCode["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+    HttpCode[HttpCode["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpCode[HttpCode["CONFLICT"] = 409] = "CONFLICT";
+    HttpCode[HttpCode["GONE"] = 410] = "GONE";
+    HttpCode[HttpCode["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HttpCode[HttpCode["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpCode[HttpCode["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpCode[HttpCode["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HttpCode[HttpCode["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpCode[HttpCode["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    HttpCode[HttpCode["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HttpCode[HttpCode["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpCode[HttpCode["MISDIRECTED"] = 421] = "MISDIRECTED";
+    HttpCode[HttpCode["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpCode[HttpCode["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HttpCode[HttpCode["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpCode[HttpCode["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpCode[HttpCode["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpCode[HttpCode["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpCode[HttpCode["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpCode[HttpCode["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpCode[HttpCode["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpCode[HttpCode["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+})(HttpCode || (exports.HttpCode = HttpCode = {}));

package/dist/commons/index.d.ts

@@ -0,0 +1,3 @@
+export * from './registries/ProviderControl';
+export * from './registries/ProviderRegistry';
+export * from './decorators';

package/dist/commons/index.js

@@ -0,0 +1,19 @@
+"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("./registries/ProviderControl"), exports);
+__exportStar(require("./registries/ProviderRegistry"), exports);
+__exportStar(require("./decorators"), exports);

package/dist/commons/registries/ProviderControl.d.ts

@@ -0,0 +1,77 @@
+import { ProviderType } from '../../domain/provider-type';
+import { Provider } from '../../domain/provider';
+import { ProviderScope } from '../../domain/provider-scope';
+import { InjectorService } from '../../container/InjectorService';
+import { LocalsContainer } from '../../domain/LocalsContainer';
+export interface ResolvedInvokeOptions {
+    token: TokenProvider;
+    parent?: TokenProvider;
+    scope: ProviderScope;
+    deps: TokenProvider[];
+    imports: TokenProvider[];
+    provider: Provider;
+    construct(deps: TokenProvider[]): any;
+}
+export type ProviderSettings = {
+    injectable?: boolean;
+    model?: Type<Provider>;
+    /**
+     *
+     * @param provider
+     * @param {Map<string | Function, any>} locals
+     * @param options
+     */
+    onInvoke?(provider: Provider, locals: Map<string | Function, any>, options: ResolvedInvokeOptions & {
+        injector: InjectorService;
+    }): void;
+};
+export interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}
+export type TokenProvider<T = any> = string | symbol | Type<T> | Function | any;
+export interface TokenProviderOpts {
+    token?: TokenProvider;
+    use: any;
+}
+declare class ProviderControl extends Map<TokenProvider, Provider> {
+    settings: Map<string, ProviderSettings>;
+    /**
+     * The get() method returns a specified element from a Map object.
+     * @param key Required. The key of the element to return from the Map object.
+     * @returns Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
+     */
+    get(key: TokenProvider): Provider | undefined;
+    /**
+     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+     * @param key
+     * @returns {boolean}
+     */
+    has(key: TokenProvider): boolean;
+    /**
+     * The set() method adds or updates an element with a specified key and value to a Map object.
+     * @param key Required. The key of the element to add to the Map object.
+     * @param metadata Required. The value of the element to add to the Map object.
+     */
+    set(key: TokenProvider, metadata: Provider): this;
+    /**
+     *
+     * @param target
+     * @param options
+     */
+    merge(target: TokenProvider, options: Partial<Provider>): Provider;
+    getByType(type: ProviderType): Provider[];
+    createRegistry(type: string, model: Type<Provider>, options?: Partial<ProviderSettings>): this;
+    getRegistrySettings(target: string | TokenProvider): ProviderSettings;
+    createRegisterFn(type: string): (provider: any | Provider, instance?: any) => void;
+    onInvoke(provider: Provider, locals: LocalsContainer, options: ResolvedInvokeOptions & {
+        injector: InjectorService;
+    }): void;
+    /**
+     *
+     * @param key
+     * @param options
+     */
+    protected createIfNotExists(key: TokenProvider, options: Partial<Provider>): Provider;
+}
+export declare const GlobalProvider: ProviderControl;
+export {};

package/dist/commons/registries/ProviderControl.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalProvider = void 0;
+const provider_type_1 = require("../../domain/provider-type");
+const provider_1 = require("../../domain/provider");
+const utils_1 = require("../../utils");
+class ProviderControl extends Map {
+    constructor() {
+        super(...arguments);
+        this.settings = new Map();
+    }
+    /**
+     * The get() method returns a specified element from a Map object.
+     * @param key Required. The key of the element to return from the Map object.
+     * @returns Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
+     */
+    get(key) {
+        return super.get((0, utils_1.getClassOrSymbol)(key));
+    }
+    /**
+     * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+     * @param key
+     * @returns {boolean}
+     */
+    has(key) {
+        return super.has((0, utils_1.getClassOrSymbol)(key));
+    }
+    /**
+     * The set() method adds or updates an element with a specified key and value to a Map object.
+     * @param key Required. The key of the element to add to the Map object.
+     * @param metadata Required. The value of the element to add to the Map object.
+     */
+    set(key, metadata) {
+        super.set((0, utils_1.getClassOrSymbol)(key), metadata);
+        return this;
+    }
+    /**
+     *
+     * @param target
+     * @param options
+     */
+    merge(target, options) {
+        let meta = this.createIfNotExists(target, options);
+        Object.keys(options).forEach((key) => {
+            // @ts-ignore
+            meta[key] = options[key];
+        });
+        this.set(target, meta);
+        return meta;
+    }
+    getByType(type) {
+        let result = [];
+        this.forEach((value, key) => {
+            if (value.type === type) {
+                result.push(value);
+                return;
+            }
+        });
+        return result;
+    }
+    createRegistry(type, model, options = {}) {
+        const defaultOptions = this.getRegistrySettings(type);
+        options = Object.assign(defaultOptions, {
+            ...options,
+            model
+        });
+        this.settings.set(type, options);
+        return this;
+    }
+    getRegistrySettings(target) {
+        let type = "provider";
+        if (typeof target === "string") {
+            type = target;
+        }
+        else {
+            const provider = this.get(target);
+            if (provider) {
+                type = provider.type;
+            }
+        }
+        return (this.settings.get(type) || {
+            model: provider_1.Provider
+        });
+    }
+    createRegisterFn(type) {
+        return (provider, instance) => {
+            provider = Object.assign({ instance }, provider, { type });
+            this.merge(provider.provide, provider);
+        };
+    }
+    onInvoke(provider, locals, options) {
+        const settings = this.settings.get(provider.type);
+        if (settings?.onInvoke) {
+            settings.onInvoke(provider, locals, options);
+        }
+    }
+    /**
+     *
+     * @param key
+     * @param options
+     */
+    createIfNotExists(key, options) {
+        const type = options.type || provider_type_1.ProviderType.PROVIDER;
+        if (!this.has(key)) {
+            const { model = provider_1.Provider } = this.settings.get(type) || {};
+            const item = new model(key, options);
+            this.set(key, item);
+        }
+        return this.get(key);
+    }
+}
+exports.GlobalProvider = new ProviderControl();

package/dist/commons/registries/ProviderRegistry.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from '../../domain/provider';
+export declare const registerController: (provider: any | Provider, instance?: any) => void;
+/**
+ * Register a provider configuration.
+ * @param {Provider<any>} provider
+ */
+export declare function registerProvider(provider: Partial<Provider>): Provider;

package/dist/commons/registries/ProviderRegistry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerController = void 0;
+exports.registerProvider = registerProvider;
+const provider_1 = require("../../domain/provider");
+const provider_type_1 = require("../../domain/provider-type");
+const ProviderControl_1 = require("./ProviderControl");
+ProviderControl_1.GlobalProvider.createRegistry(provider_type_1.ProviderType.CONTROLLER, provider_1.Provider);
+ProviderControl_1.GlobalProvider.createRegistry(provider_type_1.ProviderType.ROUTES, provider_1.Provider);
+exports.registerController = ProviderControl_1.GlobalProvider.createRegisterFn(provider_type_1.ProviderType.CONTROLLER);
+/**
+ * Register a provider configuration.
+ * @param {Provider<any>} provider
+ */
+function registerProvider(provider) {
+    if (!provider.provide) {
+        throw new Error("Provider.provide is required");
+    }
+    return ProviderControl_1.GlobalProvider.merge(provider.provide, provider);
+}

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const CONTROLLER = "carno:controller";
+export declare const CONTROLLER_ROUTES = "carno:controller:routes";
+export declare const CONTROLLER_MIDDLEWARES = "carno:controller:middlewares";
+export declare const CONTROLLER_EVENTS = "carno:controller:events";
+export declare const ROUTE_PARAM = "carno:route:param";
+export declare const ROUTE_MIDDLEWARES = "carno:route:middlewares";
+export declare const PROVIDER = "carno:provider";

package/dist/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER = exports.ROUTE_MIDDLEWARES = exports.ROUTE_PARAM = exports.CONTROLLER_EVENTS = exports.CONTROLLER_MIDDLEWARES = exports.CONTROLLER_ROUTES = exports.CONTROLLER = void 0;
+exports.CONTROLLER = "carno:controller";
+exports.CONTROLLER_ROUTES = "carno:controller:routes";
+exports.CONTROLLER_MIDDLEWARES = "carno:controller:middlewares";
+exports.CONTROLLER_EVENTS = "carno:controller:events";
+exports.ROUTE_PARAM = "carno:route:param";
+exports.ROUTE_MIDDLEWARES = "carno:route:middlewares";
+exports.PROVIDER = "carno:provider";

package/dist/container/ContainerConfiguration.d.ts

@@ -0,0 +1,45 @@
+import { Env } from 'bun';
+import { TokenProvider, TokenProviderOpts } from '../commons';
+import { CarnoMiddleware, Provider, ProviderScope } from '../domain';
+export type TokenRoute = {
+    method: string;
+    path: string;
+    methodName: string;
+    middlewares: CarnoMiddleware[];
+};
+export type TokenRouteWithProvider = TokenRoute & {
+    provider: Provider;
+};
+export type TokenRouteWithProviderMap = Map<string, TokenRouteWithProvider[]>;
+export declare class ContainerConfiguration {
+    readonly default: Map<string, any>;
+    protected map: Map<string, any>;
+    constructor(initialProps?: {});
+    get version(): string;
+    set version(v: string);
+    get rootDir(): string;
+    set rootDir(value: string);
+    get env(): Env;
+    set env(value: Env);
+    get scopes(): Record<string, ProviderScope>;
+    set scopes(value: Record<string, ProviderScope>);
+    get imports(): (TokenProvider | TokenProviderOpts)[];
+    set imports(imports: (TokenProvider | TokenProviderOpts)[]);
+    get routes(): TokenRouteWithProviderMap;
+    set routes(routes: TokenRouteWithProviderMap);
+    /**
+   *
+   * @param propertyKey
+   * @param value
+   */
+    set(propertyKey: string | Partial<ContainerConfiguration>, value?: any): this;
+    setRaw(propertyKey: string, value: any): this;
+    /**
+   *
+   * @param propertyKey
+   * @param defaultValue
+   * @returns {undefined|any}
+   */
+    get<T = any>(propertyKey: string, defaultValue?: T): T;
+    protected getRaw(propertyKey: string, defaultValue?: any): any;
+}

package/dist/container/ContainerConfiguration.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerConfiguration = void 0;
+const __1 = require("..");
+class ContainerConfiguration {
+    constructor(initialProps = {}) {
+        this.default = new Map();
+        this.map = new Map();
+        Object.entries({
+            scopes: {},
+            resolvers: [],
+            imports: [],
+            logger: {},
+            ...initialProps
+        }).forEach(([key, value]) => {
+            this.default.set(key, value);
+        });
+    }
+    get version() {
+        return this.get("version");
+    }
+    set version(v) {
+        this.map.set("version", v);
+    }
+    get rootDir() {
+        return this.get("rootDir");
+    }
+    set rootDir(value) {
+        this.map.set("rootDir", value);
+    }
+    get env() {
+        return this.map.get("env");
+    }
+    set env(value) {
+        this.map.set("env", value);
+    }
+    get scopes() {
+        return this.map.get("scopes");
+    }
+    set scopes(value) {
+        this.map.set("scopes", value);
+    }
+    //    get resolvers(): DIResolver[] {
+    //        return this.getRaw("resolvers");
+    //    }
+    //
+    //    set resolvers(resolvers: DIResolver[]) {
+    //        this.map.set("resolvers", resolvers);
+    //    }
+    get imports() {
+        return this.get("imports");
+    }
+    set imports(imports) {
+        this.map.set("imports", imports);
+    }
+    get routes() {
+        return this.get("routes");
+    }
+    set routes(routes) {
+        this.map.set("routes", routes);
+    }
+    //    get logger(): Partial<DILoggerOptions> {
+    //        return this.get("logger");
+    //    }
+    //
+    //    set logger(value: Partial<DILoggerOptions>) {
+    //        const logger = {...this.logger, ...value};
+    //        this.map.set("logger", logger);
+    //    }
+    //    get debug(): boolean {
+    //        return this.logger.level === "debug";
+    //    }
+    //
+    //    set debug(debug: boolean) {
+    //        this.logger = {...this.logger, level: debug ? "debug" : "info"};
+    //    }
+    /**
+   *
+   * @param propertyKey
+   * @param value
+   */
+    set(propertyKey, value) {
+        if (typeof propertyKey === "string") {
+            if (Reflect.has(this, propertyKey)) {
+                // @ts-ignore
+                this[propertyKey] = value;
+            }
+            else {
+                this.setRaw(propertyKey, value);
+            }
+        }
+        else {
+            Object.entries(propertyKey).forEach(([key, value]) => {
+                this.set(key, value);
+            });
+        }
+        return this;
+    }
+    setRaw(propertyKey, value) {
+        (0, __1.setValue)(this.map, propertyKey, value);
+        return this;
+    }
+    /**
+   *
+   * @param propertyKey
+   * @param defaultValue
+   * @returns {undefined|any}
+   */
+    get(propertyKey, defaultValue) {
+        return this.getRaw(propertyKey, defaultValue);
+    }
+    getRaw(propertyKey, defaultValue) {
+        const value = this.map.get(propertyKey);
+        if (value !== undefined) {
+            return value;
+        }
+        // @ts-ignore
+        return this.map[propertyKey] ?? defaultValue;
+    }
+}
+exports.ContainerConfiguration = ContainerConfiguration;

package/dist/container/DependencyResolver.d.ts

@@ -0,0 +1,18 @@
+import { TokenProvider } from "../commons/registries/ProviderControl";
+import { LocalsContainer } from "../domain/LocalsContainer";
+import { Provider } from "../domain/provider";
+import { Container } from "./container";
+export declare class DependencyResolver {
+    private container;
+    constructor(container: Container);
+    resolve(provider: Provider, locals: LocalsContainer, invokeCallback: (token: TokenProvider, locals: LocalsContainer) => any): any;
+    private validateProvider;
+    private determineScope;
+    private hasRequestScopeDependency;
+    private createInstance;
+    private resolveServices;
+    private handleScope;
+    private handleSingleton;
+    private handleRequest;
+    getConstructorDependencies(target: TokenProvider, propertyKey?: string | symbol | undefined): TokenProvider[];
+}

package/dist/container/DependencyResolver.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyResolver = void 0;
+const Metadata_1 = require("../domain/Metadata");
+const provider_scope_1 = require("../domain/provider-scope");
+const getClassOrSymbol_1 = require("../utils/getClassOrSymbol");
+const isPrimitiveType_1 = require("../utils/isPrimitiveType");
+class DependencyResolver {
+    constructor(container) {
+        this.container = container;
+    }
+    resolve(provider, locals, invokeCallback) {
+        if (provider.instance)
+            return provider.instance;
+        this.validateProvider(provider);
+        const scope = this.determineScope(provider);
+        const instance = this.createInstance(provider, invokeCallback, locals);
+        return this.handleScope(provider, instance, scope, locals);
+    }
+    validateProvider(provider) {
+        if (!provider.useClass && !provider.useValue) {
+            throw new Error("Provider not found.");
+        }
+    }
+    determineScope(provider) {
+        if (provider.scope === provider_scope_1.ProviderScope.REQUEST) {
+            return provider_scope_1.ProviderScope.REQUEST;
+        }
+        const deps = this.getConstructorDependencies(provider.useClass);
+        const hasRequestDep = this.hasRequestScopeDependency(deps);
+        return hasRequestDep ? provider_scope_1.ProviderScope.REQUEST : provider_scope_1.ProviderScope.SINGLETON;
+    }
+    hasRequestScopeDependency(deps) {
+        if (deps.length === 0)
+            return false;
+        return deps.some((dep) => {
+            const depProvider = this.container.get(dep);
+            return depProvider?.scope === provider_scope_1.ProviderScope.REQUEST;
+        });
+    }
+    createInstance(provider, invokeCallback, locals) {
+        if (provider.useValue) {
+            return provider.useValue;
+        }
+        const deps = this.getConstructorDependencies(provider.useClass);
+        const services = this.resolveServices(deps, invokeCallback, locals);
+        return new provider.useClass(...services);
+    }
+    resolveServices(deps, invokeCallback, locals) {
+        return deps
+            .filter((t) => !(0, isPrimitiveType_1.isPrimitiveType)(t))
+            .map((token) => invokeCallback((0, getClassOrSymbol_1.getClassOrSymbol)(token), locals));
+    }
+    handleScope(provider, instance, scope, locals) {
+        switch (scope) {
+            case provider_scope_1.ProviderScope.SINGLETON:
+                return this.handleSingleton(provider, instance);
+            case provider_scope_1.ProviderScope.REQUEST:
+                return this.handleRequest(provider, instance, locals);
+            default:
+                return instance;
+        }
+    }
+    handleSingleton(provider, instance) {
+        provider.instance = instance;
+        this.container.addProvider(provider.token, provider);
+        return instance;
+    }
+    handleRequest(provider, instance, locals) {
+        const clone = provider.clone();
+        clone.instance = instance;
+        locals.set(clone.token, clone);
+        return instance;
+    }
+    getConstructorDependencies(target, propertyKey) {
+        return (Metadata_1.Metadata.getOwn("override:ctor:design:paramtypes", target, propertyKey) ||
+            [...Metadata_1.Metadata.getParamTypes(target, propertyKey)] ||
+            []);
+    }
+}
+exports.DependencyResolver = DependencyResolver;

package/dist/container/InjectorService.d.ts

@@ -0,0 +1,34 @@
+import type { ApplicationConfig } from "../Carno";
+import { TokenProvider } from "../commons/registries/ProviderControl";
+import { Context } from "../domain/Context";
+import { LocalsContainer } from "../domain/LocalsContainer";
+import { Provider } from "../domain/provider";
+import { ProviderScope } from "../domain/provider-scope";
+import { EventType } from "../events/on-event";
+import Memoirist from "../route/memoirist";
+import { ContainerConfiguration, TokenRouteWithProvider } from "./ContainerConfiguration";
+import { Container } from "./container";
+export declare class InjectorService {
+    settings: ContainerConfiguration;
+    container: Container;
+    applicationConfig: ApplicationConfig;
+    router: Memoirist<TokenRouteWithProvider>;
+    private routeResolver;
+    private dependencyResolver;
+    private methodInvoker;
+    loadModule(container: Container, applicationConfig: ApplicationConfig, router: Memoirist<any>): Promise<void>;
+    private initializeResolvers;
+    private ensureProvider;
+    get(token: TokenProvider): Provider | undefined;
+    invoke(token: TokenProvider, locals?: LocalsContainer): any;
+    invokeRoute(route: TokenRouteWithProvider, context: Context, locals: LocalsContainer): Promise<any>;
+    scopeOf(provider: Provider): ProviderScope | undefined;
+    callHook(event: EventType, data?: unknown): Promise<void>;
+    private getHooksByEvent;
+    private sortHooksByPriority;
+    private runHookHandlers;
+    private executeHook;
+    private saveInjector;
+    private removeUnknownProviders;
+    private isProviderAllowed;
+}