@expressots/core 3.0.0 → 4.0.0-preview.1

package/lib/cjs/decorator/scope-binding.js

@@ -2,60 +2,351 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.provideTransient = exports.provideSingleton = exports.provide = void 0;
-const binding_decorator_1 = require("../di/binding-decorator");
+exports.provideInScope = exports.provideTransient = exports.provideSingleton = exports.provide = void 0;
+exports.Provider = Provider;
+const index_js_1 = require("../di/binding-decorator/index.js");
 /**
- * Provides a binding for the given identifier.
+ * Internal function to store provider metadata on a class.
+ * @internal
+ */
+function storeProviderMetadata(target, scope, source, options) {
+    Reflect.defineMetadata(index_js_1.METADATA_KEY.scope, scope, target);
+    Reflect.defineMetadata(index_js_1.METADATA_KEY.source, source, target);
+    if (options) {
+        Reflect.defineMetadata(index_js_1.METADATA_KEY.providerMeta, options, target);
+    }
+}
+/**
+ * Provides a request-scoped binding for the given identifier.
  *
- * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
- * @returns A fluent interface for further configuring the binding.
+ * @layer public
+ * @audience application-developers
+ * @concept dependency-injection
+ * @difficulty beginner
+ *
+ * @summary Quick Start
+ * Register a service with request scope (one instance per HTTP request).
  *
  * @example
  * ```typescript
  * provide(ServiceIdentifier)
  * class MyService {}
  * ```
+ *
+ * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
+ * @returns A class decorator
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Behavior**
+ * - Uses `fluentProvide()` to create binding
+ * - Default scope: Request (one per HTTP request)
+ * - Stores provider metadata for introspection
+ *
+ * **Scope Behavior**
+ * - Request scope: One instance per HTTP request
+ * - Stateless and scalable
+ * - Recommended for most services
+ *
+ * @see {@link provideSingleton} for singleton scope
+ * @see {@link provideTransient} for transient scope
+ * @see {@link provideInScope} for custom scopes
+ *
  * @public API
  */
 const provide = (identifier) => {
-    return (0, binding_decorator_1.fluentProvide)(identifier).done();
+    const decorator = (0, index_js_1.fluentProvide)(identifier).done();
+    return function (target) {
+        storeProviderMetadata(target, "Request", "user");
+        return decorator(target);
+    };
 };
 exports.provide = provide;
 /**
  * Provides a singleton binding for the given identifier.
  *
- * Singleton binding ensures that the same instance of a dependency is reused within the entire container.
+ * @layer public
+ * @audience application-developers
+ * @concept dependency-injection
+ * @difficulty beginner
  *
- * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
- * @returns A fluent interface for further configuring the binding.
+ * @summary Quick Start
+ * Register a service with singleton scope (one instance for application lifetime).
  *
  * @example
  * ```typescript
  * provideSingleton(ServiceIdentifier)
  * class MyService {}
  * ```
+ *
+ * **Singleton Behavior:**
+ * - One instance shared across entire application
+ * - Created on first resolution
+ * - Cached for subsequent resolutions
+ * - Use for stateless services or caches
+ *
+ * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
+ * @param source - Optional provider source type (default: "user")
+ * @returns A class decorator
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Behavior**
+ * - Uses `fluentProvide().inSingletonScope()`
+ * - Stores metadata with scope "Singleton"
+ * - Supports provider source tracking
+ *
+ * **Use Cases**
+ * - Stateless services (loggers, caches)
+ * - Configuration services
+ * - Shared state managers
+ *
+ * @see {@link provide} for request scope
+ * @see {@link provideTransient} for transient scope
+ *
  * @public API
  */
-const provideSingleton = (identifier) => {
-    return (0, binding_decorator_1.fluentProvide)(identifier).inSingletonScope().done();
+const provideSingleton = (identifier, source = "user") => {
+    const decorator = (0, index_js_1.fluentProvide)(identifier).inSingletonScope().done();
+    return function (target) {
+        storeProviderMetadata(target, "Singleton", source);
+        return decorator(target);
+    };
 };
 exports.provideSingleton = provideSingleton;
 /**
  * Provides a transient binding for the given identifier.
  *
- * Transient binding ensures that a new instance of a dependency is created every time it is resolved.
+ * @layer public
+ * @audience application-developers
+ * @concept dependency-injection
+ * @difficulty beginner
  *
- * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
- * @returns A fluent interface for further configuring the binding.
+ * @summary Quick Start
+ * Register a service with transient scope (new instance every time).
  *
  * @example
  * ```typescript
  * provideTransient(ServiceIdentifier)
  * class MyService {}
  * ```
+ *
+ * **Transient Behavior:**
+ * - New instance created every time it's resolved
+ * - No caching or reuse
+ * - Use sparingly (performance impact)
+ *
+ * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
+ * @param source - Optional provider source type (default: "user")
+ * @returns A class decorator
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Behavior**
+ * - Uses `fluentProvide().inTransientScope()`
+ * - Stores metadata with scope "Transient"
+ * - No instance caching
+ *
+ * **Use Cases**
+ * - Services that must be fresh each time
+ * - Prototype pattern implementations
+ * - Rarely needed (prefer Request scope)
+ *
+ * @see {@link provide} for request scope (recommended)
+ * @see {@link provideSingleton} for singleton scope
+ *
  * @public API
  */
-const provideTransient = (identifier) => {
-    return (0, binding_decorator_1.fluentProvide)(identifier).inTransientScope().done();
+const provideTransient = (identifier, source = "user") => {
+    const decorator = (0, index_js_1.fluentProvide)(identifier).inTransientScope().done();
+    return function (target) {
+        storeProviderMetadata(target, "Transient", source);
+        return decorator(target);
+    };
 };
 exports.provideTransient = provideTransient;
+/**
+ * Provides a custom scope binding for the given identifier.
+ *
+ * @layer public
+ * @audience application-developers
+ * @concept dependency-injection
+ * @difficulty intermediate
+ *
+ * @summary Quick Start
+ * Register a service with a custom scope (e.g., tenant, transaction).
+ *
+ * @example
+ * ```typescript
+ * // Tenant-scoped service
+ * provideInScope(TenantServiceIdentifier, "tenant")
+ * class TenantConfigService {}
+ *
+ * // Transaction-scoped service
+ * provideInScope(TransactionServiceIdentifier, "transaction")
+ * class TransactionContext {}
+ * ```
+ *
+ * **Custom Scope Behavior:**
+ * - Instances shared within the same scope context
+ * - Different instances for different scope values
+ * - Useful for multi-tenant or transaction-scoped services
+ *
+ * @param identifier - The identifier (e.g., symbol, string, class) for the dependency being registered.
+ * @param scopeName - The name of the custom scope (e.g., "tenant", "transaction").
+ *                    Must not conflict with built-in scope names: "Singleton", "Request", "Transient".
+ * @param source - Optional provider source type (default: "user")
+ * @returns A class decorator
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Behavior**
+ * - Validates scope name (cannot be built-in scope)
+ * - Uses `fluentProvide().inScope(scopeName)`
+ * - Stores metadata with custom scope name
+ *
+ * **Scope Validation**
+ * - Throws error if scopeName is "Singleton", "Request", or "Transient"
+ * - Use corresponding decorator instead (provideSingleton, provide, provideTransient)
+ *
+ * @see {@link provide} for request scope
+ * @see {@link provideSingleton} for singleton scope
+ *
+ * @layer advanced
+ * @audience power-users
+ *
+ * **Advanced Usage**
+ *
+ * Multi-tenant services:
+ * ```typescript
+ * provideInScope(IPermissionService, "tenant")
+ * class PermissionService { }
+ * ```
+ *
+ * Transaction-scoped services:
+ * ```typescript
+ * provideInScope(ITransactionContext, "transaction")
+ * class TransactionContext { }
+ * ```
+ *
+ * @public API
+ */
+const provideInScope = (identifier, scopeName, source = "user") => {
+    if (scopeName === "Singleton" ||
+        scopeName === "Request" ||
+        scopeName === "Transient") {
+        throw new Error(`Cannot use built-in scope name "${scopeName}" as custom scope. Use the corresponding decorator instead (e.g., provideSingleton()).`);
+    }
+    const decorator = (0, index_js_1.fluentProvide)(identifier).inScope(scopeName).done();
+    return function (target) {
+        storeProviderMetadata(target, scopeName, source);
+        return decorator(target);
+    };
+};
+exports.provideInScope = provideInScope;
+/**
+ * Provider decorator with rich metadata support.
+ *
+ * @layer public
+ * @audience application-developers
+ * @concept provider-decorator
+ * @difficulty intermediate
+ *
+ * @summary Quick Start
+ * Register a provider with metadata and scope configuration.
+ *
+ * @example
+ * ```typescript
+ * // External provider (plugin)
+ * @Provider({
+ *   scope: "Singleton",
+ *   name: "Redis Cache Provider",
+ *   version: "1.0.0",
+ *   author: "ExpressoTS Team",
+ *   description: "Redis caching for ExpressoTS applications"
+ * })
+ * export class RedisCacheProvider implements IProvider {
+ *   readonly name = "Redis Cache Provider";
+ *   readonly version = "1.0.0";
+ * }
+ *
+ * // User provider with custom scope
+ * @Provider({ scope: "Request" })
+ * export class UserSessionProvider { }
+ * ```
+ *
+ * @param options - Provider configuration options
+ * @param options.scope - Binding scope (default: "Request")
+ * @param options.name - Provider display name
+ * @param options.version - Provider version
+ * @param options.description - Brief description
+ * @param options.author - Author name or organization
+ * @param options.repo - Repository URL
+ * @param options.source - Provider source type (default: "external")
+ * @param options.dependencies - Dependencies on other providers
+ * @param options.priority - Load priority (higher = later, default: 0)
+ * @returns A class decorator
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Behavior**
+ * - Stores all metadata in Reflect metadata
+ * - Applies appropriate binding based on scope
+ * - Supports discovery and introspection
+ *
+ * **Metadata Storage**
+ * - Scope, source, and provider metadata stored separately
+ * - Used by ProviderRegistry for discovery
+ * - Supports health checks and metrics
+ *
+ * @see {@link ProviderOptions} for all available options
+ * @see {@link provide} for simple request-scoped binding
+ *
+ * @layer advanced
+ * @audience power-users
+ *
+ * **Advanced Usage**
+ *
+ * With dependencies:
+ * ```typescript
+ * @Provider({
+ *   scope: "Singleton",
+ *   dependencies: ["DatabaseProvider", "CacheProvider"],
+ *   priority: 10
+ * })
+ * export class MyProvider { }
+ * ```
+ *
+ * @public API
+ */
+function Provider(options = {}) {
+    const scope = options.scope || "Request";
+    const source = options.source || "external";
+    return function (target) {
+        // Store all metadata
+        storeProviderMetadata(target, scope, source, options);
+        // Apply appropriate binding based on scope
+        let decorator;
+        switch (scope) {
+            case "Singleton":
+                decorator = (0, index_js_1.fluentProvide)(target).inSingletonScope().done();
+                break;
+            case "Transient":
+                decorator = (0, index_js_1.fluentProvide)(target).inTransientScope().done();
+                break;
+            case "Request":
+                decorator = (0, index_js_1.fluentProvide)(target).done();
+                break;
+            default:
+                // Custom scope
+                decorator = (0, index_js_1.fluentProvide)(target).inScope(scope).done();
+                break;
+        }
+        return decorator(target);
+    };
+}

package/lib/cjs/di/annotation/decorator_utils.js

@@ -27,9 +27,9 @@ exports.decorate = decorate;
 exports.tagParameter = tagParameter;
 exports.tagProperty = tagProperty;
 exports.createTaggedDecorator = createTaggedDecorator;
-const ERROR_MSGS = __importStar(require("../constants/error_msgs"));
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const js_1 = require("../utils/js");
+const ERROR_MSGS = __importStar(require("../constants/error_msgs.js"));
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const js_js_1 = require("../utils/js.js");
 function targetIsConstructorFunction(target) {
     return target.prototype !== undefined;
 }
@@ -52,7 +52,7 @@ function _ensureNoMetadataKeyDuplicates(metadata) {
     let metadatas = [];
     if (Array.isArray(metadata)) {
         metadatas = metadata;
-        const duplicate = (0, js_1.getFirstArrayDuplicate)(metadatas.map((md) => md.key));
+        const duplicate = (0, js_js_1.getFirstArrayDuplicate)(metadatas.map((md) => md.key));
         if (duplicate !== undefined) {
             throw new Error(`${ERROR_MSGS.DUPLICATED_METADATA} ${duplicate.toString()}`);
         }

package/lib/cjs/di/annotation/inject.js

@@ -24,8 +24,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inject = void 0;
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const inject_base_1 = require("./inject_base");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const inject_base_js_1 = require("./inject_base.js");
 /**
  * Marks a constructor parameter for injection.
  * @param serviceIdentifier The service identifier
@@ -40,5 +40,5 @@ const inject_base_1 = require("./inject_base");
  * ```
  * @public API
  */
-const inject = (0, inject_base_1.injectBase)(METADATA_KEY.INJECT_TAG);
+const inject = (0, inject_base_js_1.injectBase)(METADATA_KEY.INJECT_TAG);
 exports.inject = inject;

package/lib/cjs/di/annotation/inject_base.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.injectBase = injectBase;
-const error_msgs_1 = require("../constants/error_msgs");
-const metadata_1 = require("../planning/metadata");
-const decorator_utils_1 = require("./decorator_utils");
+const error_msgs_js_1 = require("../constants/error_msgs.js");
+const metadata_js_1 = require("../planning/metadata.js");
+const decorator_utils_js_1 = require("./decorator_utils.js");
 function injectBase(metadataKey) {
     return (serviceIdentifier) => {
         return (target, targetKey, indexOrPropertyDescriptor) => {
             if (serviceIdentifier === undefined) {
                 const className = typeof target === "function" ? target.name : target.constructor.name;
-                throw new Error((0, error_msgs_1.UNDEFINED_INJECT_ANNOTATION)(className));
+                throw new Error((0, error_msgs_js_1.UNDEFINED_INJECT_ANNOTATION)(className));
             }
-            return (0, decorator_utils_1.createTaggedDecorator)(new metadata_1.Metadata(metadataKey, serviceIdentifier))(target, targetKey, indexOrPropertyDescriptor);
+            return (0, decorator_utils_js_1.createTaggedDecorator)(new metadata_js_1.Metadata(metadataKey, serviceIdentifier))(target, targetKey, indexOrPropertyDescriptor);
         };
     };
 }

package/lib/cjs/di/annotation/injectable.js

@@ -24,8 +24,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.injectable = injectable;
-const ERRORS_MSGS = __importStar(require("../constants/error_msgs"));
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
+const ERRORS_MSGS = __importStar(require("../constants/error_msgs.js"));
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
 /**
  * Marks a class as injectable.
  * @returns A decorator function

package/lib/cjs/di/annotation/multi_inject.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.multiInject = void 0;
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const inject_base_1 = require("./inject_base");
-const multiInject = (0, inject_base_1.injectBase)(METADATA_KEY.MULTI_INJECT_TAG);
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const inject_base_js_1 = require("./inject_base.js");
+const multiInject = (0, inject_base_js_1.injectBase)(METADATA_KEY.MULTI_INJECT_TAG);
 exports.multiInject = multiInject;

package/lib/cjs/di/annotation/named.js

@@ -24,11 +24,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.named = named;
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const metadata_1 = require("../planning/metadata");
-const decorator_utils_1 = require("./decorator_utils");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const metadata_js_1 = require("../planning/metadata.js");
+const decorator_utils_js_1 = require("./decorator_utils.js");
 // Used to add named metadata which is used to resolve name-based contextual bindings.
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function named(name) {
-    return (0, decorator_utils_1.createTaggedDecorator)(new metadata_1.Metadata(METADATA_KEY.NAMED_TAG, name));
+    return (0, decorator_utils_js_1.createTaggedDecorator)(new metadata_js_1.Metadata(METADATA_KEY.NAMED_TAG, name));
 }

package/lib/cjs/di/annotation/optional.js

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.optional = optional;
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const metadata_1 = require("../planning/metadata");
-const decorator_utils_1 = require("./decorator_utils");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const metadata_js_1 = require("../planning/metadata.js");
+const decorator_utils_js_1 = require("./decorator_utils.js");
 function optional() {
-    return (0, decorator_utils_1.createTaggedDecorator)(new metadata_1.Metadata(METADATA_KEY.OPTIONAL_TAG, true));
+    return (0, decorator_utils_js_1.createTaggedDecorator)(new metadata_js_1.Metadata(METADATA_KEY.OPTIONAL_TAG, true));
 }

package/lib/cjs/di/annotation/post_construct.js

@@ -24,8 +24,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postConstruct = void 0;
-const ERRORS_MSGS = __importStar(require("../constants/error_msgs"));
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const property_event_decorator_1 = require("./property_event_decorator");
-const postConstruct = (0, property_event_decorator_1.propertyEventDecorator)(METADATA_KEY.POST_CONSTRUCT, ERRORS_MSGS.MULTIPLE_POST_CONSTRUCT_METHODS);
+const ERRORS_MSGS = __importStar(require("../constants/error_msgs.js"));
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const property_event_decorator_js_1 = require("./property_event_decorator.js");
+const postConstruct = (0, property_event_decorator_js_1.propertyEventDecorator)(METADATA_KEY.POST_CONSTRUCT, ERRORS_MSGS.MULTIPLE_POST_CONSTRUCT_METHODS);
 exports.postConstruct = postConstruct;

package/lib/cjs/di/annotation/pre_destroy.js

@@ -24,8 +24,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preDestroy = void 0;
-const ERRORS_MSGS = __importStar(require("../constants/error_msgs"));
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const property_event_decorator_1 = require("./property_event_decorator");
-const preDestroy = (0, property_event_decorator_1.propertyEventDecorator)(METADATA_KEY.PRE_DESTROY, ERRORS_MSGS.MULTIPLE_PRE_DESTROY_METHODS);
+const ERRORS_MSGS = __importStar(require("../constants/error_msgs.js"));
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const property_event_decorator_js_1 = require("./property_event_decorator.js");
+const preDestroy = (0, property_event_decorator_js_1.propertyEventDecorator)(METADATA_KEY.PRE_DESTROY, ERRORS_MSGS.MULTIPLE_PRE_DESTROY_METHODS);
 exports.preDestroy = preDestroy;

package/lib/cjs/di/annotation/property_event_decorator.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.propertyEventDecorator = propertyEventDecorator;
-const metadata_1 = require("../planning/metadata");
+const metadata_js_1 = require("../planning/metadata.js");
 function propertyEventDecorator(eventKey, errorMessage) {
     return () => {
         return (target, propertyKey) => {
-            const metadata = new metadata_1.Metadata(eventKey, propertyKey);
+            const metadata = new metadata_js_1.Metadata(eventKey, propertyKey);
             if (Reflect.hasOwnMetadata(eventKey, target.constructor)) {
                 throw new Error(errorMessage);
             }

package/lib/cjs/di/annotation/tagged.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tagged = tagged;
-const metadata_1 = require("../planning/metadata");
-const decorator_utils_1 = require("./decorator_utils");
+const metadata_js_1 = require("../planning/metadata.js");
+const decorator_utils_js_1 = require("./decorator_utils.js");
 // Used to add custom metadata which is used to resolve metadata-based contextual bindings.
 function tagged(metadataKey, metadataValue) {
-    return (0, decorator_utils_1.createTaggedDecorator)(new metadata_1.Metadata(metadataKey, metadataValue));
+    return (0, decorator_utils_js_1.createTaggedDecorator)(new metadata_js_1.Metadata(metadataKey, metadataValue));
 }

package/lib/cjs/di/annotation/target_name.js

@@ -24,12 +24,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.targetName = targetName;
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const metadata_1 = require("../planning/metadata");
-const decorator_utils_1 = require("./decorator_utils");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const metadata_js_1 = require("../planning/metadata.js");
+const decorator_utils_js_1 = require("./decorator_utils.js");
 function targetName(name) {
     return function (target, targetKey, index) {
-        const metadata = new metadata_1.Metadata(METADATA_KEY.NAME_TAG, name);
-        (0, decorator_utils_1.tagParameter)(target, targetKey, index, metadata);
+        const metadata = new metadata_js_1.Metadata(METADATA_KEY.NAME_TAG, name);
+        (0, decorator_utils_js_1.tagParameter)(target, targetKey, index, metadata);
     };
 }

package/lib/cjs/di/annotation/unmanaged.js

@@ -24,12 +24,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unmanaged = unmanaged;
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const metadata_1 = require("../planning/metadata");
-const decorator_utils_1 = require("./decorator_utils");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const metadata_js_1 = require("../planning/metadata.js");
+const decorator_utils_js_1 = require("./decorator_utils.js");
 function unmanaged() {
     return function (target, targetKey, index) {
-        const metadata = new metadata_1.Metadata(METADATA_KEY.UNMANAGED_TAG, true);
-        (0, decorator_utils_1.tagParameter)(target, targetKey, index, metadata);
+        const metadata = new metadata_js_1.Metadata(METADATA_KEY.UNMANAGED_TAG, true);
+        (0, decorator_utils_js_1.tagParameter)(target, targetKey, index, metadata);
     };
 }

package/lib/cjs/di/binding-decorator/constants.js

@@ -3,5 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.METADATA_KEY = void 0;
 const METADATA_KEY = {
     provide: "inversify-binding-decorators:provide",
+    scope: "expressots:provider:scope",
+    source: "expressots:provider:source",
+    providerMeta: "expressots:provider:meta",
 };
 exports.METADATA_KEY = METADATA_KEY;

package/lib/cjs/di/binding-decorator/decorator/fluent_provide.js

@@ -5,16 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-const provide_in_when_on_syntax_1 = __importDefault(require("../syntax/provide_in_when_on_syntax"));
-const provide_when_syntax_1 = __importDefault(require("../syntax/provide_when_syntax"));
-const provide_on_syntax_1 = __importDefault(require("../syntax/provide_on_syntax"));
-const provide_in_syntax_1 = __importDefault(require("../syntax/provide_in_syntax"));
-const provide_done_syntax_1 = __importDefault(require("../syntax/provide_done_syntax"));
+const provide_in_when_on_syntax_js_1 = __importDefault(require("../syntax/provide_in_when_on_syntax.js"));
+const provide_when_syntax_js_1 = __importDefault(require("../syntax/provide_when_syntax.js"));
+const provide_on_syntax_js_1 = __importDefault(require("../syntax/provide_on_syntax.js"));
+const provide_in_syntax_js_1 = __importDefault(require("../syntax/provide_in_syntax.js"));
+const provide_done_syntax_js_1 = __importDefault(require("../syntax/provide_done_syntax.js"));
 function fluentProvide(serviceIdentifier) {
     const bindingWhenOnSyntax = (bind, target) => bind(serviceIdentifier).to(target);
     const bindingConstraintFunction = (bind, target) => bindingWhenOnSyntax(bind, target)._binding;
-    const provideDoneSyntax = new provide_done_syntax_1.default(bindingConstraintFunction);
-    const provideInWhenOnSyntax = new provide_in_when_on_syntax_1.default(new provide_in_syntax_1.default((bind, target) => bindingWhenOnSyntax(bind, target), provideDoneSyntax), new provide_when_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_on_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax));
+    const provideDoneSyntax = new provide_done_syntax_js_1.default(bindingConstraintFunction);
+    const provideInWhenOnSyntax = new provide_in_when_on_syntax_js_1.default(new provide_in_syntax_js_1.default((bind, target) => bindingWhenOnSyntax(bind, target), provideDoneSyntax), new provide_when_syntax_js_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_on_syntax_js_1.default(bindingWhenOnSyntax, provideDoneSyntax));
     return provideInWhenOnSyntax;
 }
 exports.default = fluentProvide;