@expressots/core 3.0.0-beta.4 → 4.0.0-preview.1

package/lib/cjs/di/syntax/binding_in_syntax.js

@@ -1,23 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BindingInSyntax = void 0;
-const literal_types_1 = require("../constants/literal_types");
-const binding_when_on_syntax_1 = require("./binding_when_on_syntax");
+const literal_types_js_1 = require("../constants/literal_types.js");
+const binding_when_on_syntax_js_1 = require("./binding_when_on_syntax.js");
 class BindingInSyntax {
     constructor(binding) {
         this._binding = binding;
     }
     inRequestScope() {
-        this._binding.scope = literal_types_1.BindingScopeEnum.Request;
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        this._binding.scope = literal_types_js_1.Scope.Request;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
     inSingletonScope() {
-        this._binding.scope = literal_types_1.BindingScopeEnum.Singleton;
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        this._binding.scope = literal_types_js_1.Scope.Singleton;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
     inTransientScope() {
-        this._binding.scope = literal_types_1.BindingScopeEnum.Transient;
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        this._binding.scope = literal_types_js_1.Scope.Transient;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
+    }
+    inScope(scope) {
+        // Validate that custom scope name doesn't conflict with built-in scopes
+        if (scope === literal_types_js_1.Scope.Singleton ||
+            scope === literal_types_js_1.Scope.Request ||
+            scope === literal_types_js_1.Scope.Transient) {
+            throw new Error(`Cannot use built-in scope name "${scope}" as custom scope. Use the corresponding method instead (e.g., inSingletonScope()).`);
+        }
+        this._binding.scope = scope;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
 }
 exports.BindingInSyntax = BindingInSyntax;

package/lib/cjs/di/syntax/binding_in_when_on_syntax.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BindingInWhenOnSyntax = void 0;
-const binding_in_syntax_1 = require("./binding_in_syntax");
-const binding_on_syntax_1 = require("./binding_on_syntax");
-const binding_when_syntax_1 = require("./binding_when_syntax");
+const binding_in_syntax_js_1 = require("./binding_in_syntax.js");
+const binding_on_syntax_js_1 = require("./binding_on_syntax.js");
+const binding_when_syntax_js_1 = require("./binding_when_syntax.js");
 class BindingInWhenOnSyntax {
     constructor(binding) {
         this._binding = binding;
-        this._bindingWhenSyntax = new binding_when_syntax_1.BindingWhenSyntax(this._binding);
-        this._bindingOnSyntax = new binding_on_syntax_1.BindingOnSyntax(this._binding);
-        this._bindingInSyntax = new binding_in_syntax_1.BindingInSyntax(binding);
+        this._bindingWhenSyntax = new binding_when_syntax_js_1.BindingWhenSyntax(this._binding);
+        this._bindingOnSyntax = new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
+        this._bindingInSyntax = new binding_in_syntax_js_1.BindingInSyntax(binding);
     }
     inRequestScope() {
         return this._bindingInSyntax.inRequestScope();
@@ -20,6 +20,9 @@ class BindingInWhenOnSyntax {
     inTransientScope() {
         return this._bindingInSyntax.inTransientScope();
     }
+    inScope(scope) {
+        return this._bindingInSyntax.inScope(scope);
+    }
     when(constraint) {
         return this._bindingWhenSyntax.when(constraint);
     }

package/lib/cjs/di/syntax/binding_on_syntax.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BindingOnSyntax = void 0;
-const binding_when_syntax_1 = require("./binding_when_syntax");
+const binding_when_syntax_js_1 = require("./binding_when_syntax.js");
 class BindingOnSyntax {
     constructor(binding) {
         this._binding = binding;
     }
     onActivation(handler) {
         this._binding.onActivation = handler;
-        return new binding_when_syntax_1.BindingWhenSyntax(this._binding);
+        return new binding_when_syntax_js_1.BindingWhenSyntax(this._binding);
     }
     onDeactivation(handler) {
         this._binding.onDeactivation = handler;
-        return new binding_when_syntax_1.BindingWhenSyntax(this._binding);
+        return new binding_when_syntax_js_1.BindingWhenSyntax(this._binding);
     }
 }
 exports.BindingOnSyntax = BindingOnSyntax;

package/lib/cjs/di/syntax/binding_to_syntax.js

@@ -25,18 +25,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BindingToSyntax = void 0;
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
-const ERROR_MSGS = __importStar(require("../constants/error_msgs"));
-const literal_types_1 = require("../constants/literal_types");
-const binding_in_when_on_syntax_1 = require("./binding_in_when_on_syntax");
-const binding_when_on_syntax_1 = require("./binding_when_on_syntax");
+const ERROR_MSGS = __importStar(require("../constants/error_msgs.js"));
+const literal_types_js_1 = require("../constants/literal_types.js");
+const binding_in_when_on_syntax_js_1 = require("./binding_in_when_on_syntax.js");
+const binding_when_on_syntax_js_1 = require("./binding_when_on_syntax.js");
 class BindingToSyntax {
     constructor(binding) {
         this._binding = binding;
     }
     to(constructor) {
-        this._binding.type = literal_types_1.BindingTypeEnum.Instance;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.Instance;
         this._binding.implementationType = constructor;
-        return new binding_in_when_on_syntax_1.BindingInWhenOnSyntax(this._binding);
+        return new binding_in_when_on_syntax_js_1.BindingInWhenOnSyntax(this._binding);
     }
     toSelf() {
         if (typeof this._binding.serviceIdentifier !== "function") {
@@ -46,31 +46,31 @@ class BindingToSyntax {
         return this.to(self);
     }
     toConstantValue(value) {
-        this._binding.type = literal_types_1.BindingTypeEnum.ConstantValue;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.ConstantValue;
         this._binding.cache = value;
         this._binding.dynamicValue = null;
         this._binding.implementationType = null;
-        this._binding.scope = literal_types_1.BindingScopeEnum.Singleton;
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        this._binding.scope = literal_types_js_1.Scope.Singleton;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
     toDynamicValue(func) {
-        this._binding.type = literal_types_1.BindingTypeEnum.DynamicValue;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.DynamicValue;
         this._binding.cache = null;
         this._binding.dynamicValue = func;
         this._binding.implementationType = null;
-        return new binding_in_when_on_syntax_1.BindingInWhenOnSyntax(this._binding);
+        return new binding_in_when_on_syntax_js_1.BindingInWhenOnSyntax(this._binding);
     }
     toConstructor(constructor) {
-        this._binding.type = literal_types_1.BindingTypeEnum.Constructor;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.Constructor;
         this._binding.implementationType = constructor;
-        this._binding.scope = literal_types_1.BindingScopeEnum.Singleton;
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        this._binding.scope = literal_types_js_1.Scope.Singleton;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
     toFactory(factory) {
-        this._binding.type = literal_types_1.BindingTypeEnum.Factory;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.Factory;
         this._binding.factory = factory;
-        this._binding.scope = literal_types_1.BindingScopeEnum.Singleton;
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        this._binding.scope = literal_types_js_1.Scope.Singleton;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
     toFunction(func) {
         // toFunction is an alias of toConstantValue
@@ -78,31 +78,31 @@ class BindingToSyntax {
             throw new Error(ERROR_MSGS.INVALID_FUNCTION_BINDING);
         }
         const bindingWhenOnSyntax = this.toConstantValue(func);
-        this._binding.type = literal_types_1.BindingTypeEnum.Function;
-        this._binding.scope = literal_types_1.BindingScopeEnum.Singleton;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.Function;
+        this._binding.scope = literal_types_js_1.Scope.Singleton;
         return bindingWhenOnSyntax;
     }
     toAutoFactory(serviceIdentifier) {
-        this._binding.type = literal_types_1.BindingTypeEnum.Factory;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.Factory;
         this._binding.factory = (context) => {
             const autofactory = () => context.container.get(serviceIdentifier);
             return autofactory;
         };
-        this._binding.scope = literal_types_1.BindingScopeEnum.Singleton;
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        this._binding.scope = literal_types_js_1.Scope.Singleton;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
     toAutoNamedFactory(serviceIdentifier) {
-        this._binding.type = literal_types_1.BindingTypeEnum.Factory;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.Factory;
         this._binding.factory = (context) => {
             return (named) => context.container.getNamed(serviceIdentifier, named);
         };
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
     toProvider(provider) {
-        this._binding.type = literal_types_1.BindingTypeEnum.Provider;
+        this._binding.type = literal_types_js_1.BindingTypeEnum.Provider;
         this._binding.provider = provider;
-        this._binding.scope = literal_types_1.BindingScopeEnum.Singleton;
-        return new binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
+        this._binding.scope = literal_types_js_1.Scope.Singleton;
+        return new binding_when_on_syntax_js_1.BindingWhenOnSyntax(this._binding);
     }
     toService(service) {
         this.toDynamicValue((context) => context.container.get(service));

package/lib/cjs/di/syntax/binding_when_on_syntax.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BindingWhenOnSyntax = void 0;
-const binding_on_syntax_1 = require("./binding_on_syntax");
-const binding_when_syntax_1 = require("./binding_when_syntax");
+const binding_on_syntax_js_1 = require("./binding_on_syntax.js");
+const binding_when_syntax_js_1 = require("./binding_when_syntax.js");
 class BindingWhenOnSyntax {
     constructor(binding) {
         this._binding = binding;
-        this._bindingWhenSyntax = new binding_when_syntax_1.BindingWhenSyntax(this._binding);
-        this._bindingOnSyntax = new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._bindingWhenSyntax = new binding_when_syntax_js_1.BindingWhenSyntax(this._binding);
+        this._bindingOnSyntax = new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     when(constraint) {
         return this._bindingWhenSyntax.when(constraint);

package/lib/cjs/di/syntax/binding_when_syntax.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BindingWhenSyntax = void 0;
-const binding_on_syntax_1 = require("./binding_on_syntax");
-const constraint_helpers_1 = require("./constraint_helpers");
+const binding_on_syntax_js_1 = require("./binding_on_syntax.js");
+const constraint_helpers_js_1 = require("./constraint_helpers.js");
 class BindingWhenSyntax {
     constructor(binding) {
         this._binding = binding;
     }
     when(constraint) {
         this._binding.constraint = constraint;
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenTargetNamed(name) {
-        this._binding.constraint = (0, constraint_helpers_1.namedConstraint)(name);
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._binding.constraint = (0, constraint_helpers_js_1.namedConstraint)(name);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenTargetIsDefault() {
         this._binding.constraint = (request) => {
@@ -25,60 +25,60 @@ class BindingWhenSyntax {
                 !request.target.isTagged();
             return targetIsDefault;
         };
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenTargetTagged(tag, value) {
-        this._binding.constraint = (0, constraint_helpers_1.taggedConstraint)(tag)(value);
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._binding.constraint = (0, constraint_helpers_js_1.taggedConstraint)(tag)(value);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenInjectedInto(parent) {
-        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_1.typeConstraint)(parent)(request.parentRequest);
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_js_1.typeConstraint)(parent)(request.parentRequest);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenParentNamed(name) {
-        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_1.namedConstraint)(name)(request.parentRequest);
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_js_1.namedConstraint)(name)(request.parentRequest);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenParentTagged(tag, value) {
-        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_1.taggedConstraint)(tag)(value)(request.parentRequest);
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_js_1.taggedConstraint)(tag)(value)(request.parentRequest);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenAnyAncestorIs(ancestor) {
-        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_1.traverseAncerstors)(request, (0, constraint_helpers_1.typeConstraint)(ancestor));
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_js_1.traverseAncerstors)(request, (0, constraint_helpers_js_1.typeConstraint)(ancestor));
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenNoAncestorIs(ancestor) {
         this._binding.constraint = (request) => request !== null &&
-            !(0, constraint_helpers_1.traverseAncerstors)(request, (0, constraint_helpers_1.typeConstraint)(ancestor));
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+            !(0, constraint_helpers_js_1.traverseAncerstors)(request, (0, constraint_helpers_js_1.typeConstraint)(ancestor));
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenAnyAncestorNamed(name) {
-        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_1.traverseAncerstors)(request, (0, constraint_helpers_1.namedConstraint)(name));
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._binding.constraint = (request) => request !== null && (0, constraint_helpers_js_1.traverseAncerstors)(request, (0, constraint_helpers_js_1.namedConstraint)(name));
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenNoAncestorNamed(name) {
-        this._binding.constraint = (request) => request !== null && !(0, constraint_helpers_1.traverseAncerstors)(request, (0, constraint_helpers_1.namedConstraint)(name));
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+        this._binding.constraint = (request) => request !== null && !(0, constraint_helpers_js_1.traverseAncerstors)(request, (0, constraint_helpers_js_1.namedConstraint)(name));
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenAnyAncestorTagged(tag, value) {
         this._binding.constraint = (request) => request !== null &&
-            (0, constraint_helpers_1.traverseAncerstors)(request, (0, constraint_helpers_1.taggedConstraint)(tag)(value));
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+            (0, constraint_helpers_js_1.traverseAncerstors)(request, (0, constraint_helpers_js_1.taggedConstraint)(tag)(value));
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenNoAncestorTagged(tag, value) {
         this._binding.constraint = (request) => request !== null &&
-            !(0, constraint_helpers_1.traverseAncerstors)(request, (0, constraint_helpers_1.taggedConstraint)(tag)(value));
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+            !(0, constraint_helpers_js_1.traverseAncerstors)(request, (0, constraint_helpers_js_1.taggedConstraint)(tag)(value));
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenAnyAncestorMatches(constraint) {
         this._binding.constraint = (request) => request !== null &&
-            (0, constraint_helpers_1.traverseAncerstors)(request, constraint);
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+            (0, constraint_helpers_js_1.traverseAncerstors)(request, constraint);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
     whenNoAncestorMatches(constraint) {
         this._binding.constraint = (request) => request !== null &&
-            !(0, constraint_helpers_1.traverseAncerstors)(request, constraint);
-        return new binding_on_syntax_1.BindingOnSyntax(this._binding);
+            !(0, constraint_helpers_js_1.traverseAncerstors)(request, constraint);
+        return new binding_on_syntax_js_1.BindingOnSyntax(this._binding);
     }
 }
 exports.BindingWhenSyntax = BindingWhenSyntax;

package/lib/cjs/di/syntax/constraint_helpers.js

@@ -24,8 +24,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typeConstraint = exports.namedConstraint = exports.taggedConstraint = exports.traverseAncerstors = void 0;
-const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
-const metadata_1 = require("../planning/metadata");
+const METADATA_KEY = __importStar(require("../constants/metadata_keys.js"));
+const metadata_js_1 = require("../planning/metadata.js");
 const traverseAncerstors = (request, constraint) => {
     const parent = request.parentRequest;
     if (parent !== null) {
@@ -41,7 +41,7 @@ const taggedConstraint = (key) => (value) => {
     const constraint = (request) => request !== null &&
         request.target !== null &&
         request.target.matchesTag(key)(value);
-    constraint.metaData = new metadata_1.Metadata(key, value);
+    constraint.metaData = new metadata_js_1.Metadata(key, value);
     return constraint;
 };
 exports.taggedConstraint = taggedConstraint;

package/lib/cjs/di/utils/binding_utils.js

@@ -24,51 +24,51 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFactoryDetails = exports.ensureFullyBound = exports.multiBindToService = void 0;
-const serialization_1 = require("../utils/serialization");
-const ERROR_MSGS = __importStar(require("../constants/error_msgs"));
-const literal_types_1 = require("../constants/literal_types");
-const factory_type_1 = require("./factory_type");
+const serialization_js_1 = require("../utils/serialization.js");
+const ERROR_MSGS = __importStar(require("../constants/error_msgs.js"));
+const literal_types_js_1 = require("../constants/literal_types.js");
+const factory_type_js_1 = require("./factory_type.js");
 const multiBindToService = (container) => (service) => (...types) => types.forEach((t) => container.bind(t).toService(service));
 exports.multiBindToService = multiBindToService;
 const ensureFullyBound = (binding) => {
     let boundValue = null;
     switch (binding.type) {
-        case literal_types_1.BindingTypeEnum.ConstantValue:
-        case literal_types_1.BindingTypeEnum.Function:
+        case literal_types_js_1.BindingTypeEnum.ConstantValue:
+        case literal_types_js_1.BindingTypeEnum.Function:
             boundValue = binding.cache;
             break;
-        case literal_types_1.BindingTypeEnum.Constructor:
-        case literal_types_1.BindingTypeEnum.Instance:
+        case literal_types_js_1.BindingTypeEnum.Constructor:
+        case literal_types_js_1.BindingTypeEnum.Instance:
             boundValue = binding.implementationType;
             break;
-        case literal_types_1.BindingTypeEnum.DynamicValue:
+        case literal_types_js_1.BindingTypeEnum.DynamicValue:
             boundValue = binding.dynamicValue;
             break;
-        case literal_types_1.BindingTypeEnum.Provider:
+        case literal_types_js_1.BindingTypeEnum.Provider:
             boundValue = binding.provider;
             break;
-        case literal_types_1.BindingTypeEnum.Factory:
+        case literal_types_js_1.BindingTypeEnum.Factory:
             boundValue = binding.factory;
             break;
     }
     if (boundValue === null) {
         // The user probably created a binding but didn't finish it
         // e.g. container.bind<T>('Something'); missing BindingToSyntax
-        const serviceIdentifierAsString = (0, serialization_1.getServiceIdentifierAsString)(binding.serviceIdentifier);
+        const serviceIdentifierAsString = (0, serialization_js_1.getServiceIdentifierAsString)(binding.serviceIdentifier);
         throw new Error(`${ERROR_MSGS.INVALID_BINDING_TYPE} ${serviceIdentifierAsString}`);
     }
 };
 exports.ensureFullyBound = ensureFullyBound;
 const getFactoryDetails = (binding) => {
     switch (binding.type) {
-        case literal_types_1.BindingTypeEnum.Factory:
-            return { factory: binding.factory, factoryType: factory_type_1.FactoryType.Factory };
-        case literal_types_1.BindingTypeEnum.Provider:
-            return { factory: binding.provider, factoryType: factory_type_1.FactoryType.Provider };
-        case literal_types_1.BindingTypeEnum.DynamicValue:
+        case literal_types_js_1.BindingTypeEnum.Factory:
+            return { factory: binding.factory, factoryType: factory_type_js_1.FactoryType.Factory };
+        case literal_types_js_1.BindingTypeEnum.Provider:
+            return { factory: binding.provider, factoryType: factory_type_js_1.FactoryType.Provider };
+        case literal_types_js_1.BindingTypeEnum.DynamicValue:
             return {
                 factory: binding.dynamicValue,
-                factoryType: factory_type_1.FactoryType.DynamicValue,
+                factoryType: factory_type_js_1.FactoryType.DynamicValue,
             };
         default:
             throw new Error(`Unexpected factory type ${binding.type}`);

package/lib/cjs/di/utils/exceptions.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryAndThrowErrorIfStackOverflow = void 0;
 exports.isStackOverflowExeption = isStackOverflowExeption;
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
-const ERROR_MSGS = __importStar(require("../constants/error_msgs"));
+const ERROR_MSGS = __importStar(require("../constants/error_msgs.js"));
 function isStackOverflowExeption(error) {
     return (error instanceof RangeError ||
         error.message === ERROR_MSGS.STACK_OVERFLOW);

package/lib/cjs/di/utils/serialization.js

@@ -29,7 +29,7 @@ exports.listRegisteredBindingsForServiceIdentifier = listRegisteredBindingsForSe
 exports.listMetadataForTarget = listMetadataForTarget;
 exports.circularDependencyToException = circularDependencyToException;
 exports.getSymbolDescription = getSymbolDescription;
-const ERROR_MSGS = __importStar(require("../constants/error_msgs"));
+const ERROR_MSGS = __importStar(require("../constants/error_msgs.js"));
 function getServiceIdentifierAsString(serviceIdentifier) {
     if (typeof serviceIdentifier === "function") {
         const _serviceIdentifier = serviceIdentifier;

package/lib/cjs/error/app-error.js

@@ -1,29 +1,173 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppError = void 0;
+const status_code_js_1 = require("./status-code.js");
 /**
- * The AppError class extends the built-in Error class in JavaScript,
- * providing additional properties to manage custom application errors.
- * It captures detailed information about the error, including a status code
- * and an optional service identifier, which can be useful for error handling
- * and logging within the application.
+ * Application error class with RFC 7807 Problem Details support.
  *
- * @extends {Error}
+ * @layer public
+ * @audience application-developers
+ * @concept error-handling
+ * @difficulty beginner
+ *
+ * @summary Quick Start
+ * Create application errors with HTTP status codes and rich metadata.
+ *
+ * @example
+ * ```typescript
+ * // Simple error
+ * throw new AppError("User not found", 404);
+ *
+ * // With helper methods
+ * throw AppError.notFound("User", "123");
+ * throw AppError.badRequest("Invalid input", { field: "email" });
+ * ```
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Architecture**
+ *
+ * AppError extends Error with:
+ * - HTTP status code mapping
+ * - RFC 7807 Problem Details format
+ * - Rich metadata (errorCode, details, validationErrors)
+ * - Request correlation (requestId)
+ * - Timestamp tracking
+ *
+ * **Design Decisions**
+ * - Extends native Error for stack traces
+ * - RFC 7807 compliance for API consistency
+ * - Helper methods for common HTTP errors
+ * - Validation error support
+ *
+ * @see {@link StatusCode} for HTTP status codes
+ * @see {@link Report} for error reporting utility
+ *
+ * @layer advanced
+ * @audience power-users
+ *
+ * **Advanced Usage**
+ *
+ * With validation errors:
+ * ```typescript
+ * throw AppError.validationFailed([
+ *   { property: "email", messages: ["Invalid email format"] },
+ *   { property: "age", messages: ["Must be 18 or older"] }
+ * ]);
+ * ```
+ *
+ * With custom metadata:
+ * ```typescript
+ * throw new AppError("Custom error", 400, "MyService", {
+ *   errorCode: "CUSTOM_ERROR",
+ *   details: { userId: 123 },
+ *   requestId: "req-123"
+ * });
+ * ```
+ *
+ * @public API
  */
 class AppError extends Error {
     /**
      * @param {string} message - The error message to be displayed.
      * @param {number} [statusCode=500] - The HTTP status code associated with the error (default: 500).
      * @param {string} [service] - The service identifier associated with the error.
+     * @param {AppErrorOptions} [options] - Additional error metadata options.
      */
-    constructor(message, statusCode, service) {
+    constructor(message, statusCode, service, options) {
         super(message);
-        this.statusCode = statusCode;
+        this.statusCode = statusCode || status_code_js_1.StatusCode.InternalServerError;
         if (message === null) {
             this.message = "";
         }
         this.service = service !== undefined ? service : undefined;
+        this.errorCode = options?.errorCode;
+        this.details = options?.details;
+        this.instance = options?.instance;
+        this.type =
+            options?.type || `https://expressots.dev/errors/${this.statusCode}`;
+        this.timestamp = new Date();
+        this.requestId = options?.requestId;
+        this.validationErrors = options?.validationErrors;
         Error.captureStackTrace(this, this.constructor);
     }
+    /**
+     * Creates a BadRequest (400) error
+     */
+    static badRequest(message, details) {
+        return new AppError(message, status_code_js_1.StatusCode.BadRequest, undefined, {
+            type: "https://expressots.dev/errors/bad-request",
+            details,
+        });
+    }
+    /**
+     * Creates a NotFound (404) error
+     */
+    static notFound(resource, id) {
+        return new AppError(`${resource}${id ? ` with id ${id}` : ""} not found`, status_code_js_1.StatusCode.NotFound, undefined, {
+            type: "https://expressots.dev/errors/not-found",
+            details: { resource, id },
+        });
+    }
+    /**
+     * Creates an Unauthorized (401) error
+     */
+    static unauthorized(message = "Unauthorized") {
+        return new AppError(message, status_code_js_1.StatusCode.Unauthorized, undefined, {
+            type: "https://expressots.dev/errors/unauthorized",
+        });
+    }
+    /**
+     * Creates a Forbidden (403) error
+     */
+    static forbidden(message = "Forbidden") {
+        return new AppError(message, status_code_js_1.StatusCode.Forbidden, undefined, {
+            type: "https://expressots.dev/errors/forbidden",
+        });
+    }
+    /**
+     * Creates an UnprocessableEntity (422) validation error
+     */
+    static validationFailed(errors) {
+        return new AppError("Validation failed", status_code_js_1.StatusCode.UnprocessableEntity, undefined, {
+            type: "https://expressots.dev/errors/validation-failed",
+            validationErrors: errors,
+        });
+    }
+    /**
+     * Creates a Conflict (409) error
+     */
+    static conflict(message, details) {
+        return new AppError(message, status_code_js_1.StatusCode.Conflict, undefined, {
+            type: "https://expressots.dev/errors/conflict",
+            details,
+        });
+    }
+    /**
+     * Converts the error to RFC 7807 Problem Details format
+     */
+    toProblemDetails() {
+        const problem = {
+            type: this.type,
+            title: this.message,
+            status: this.statusCode,
+            instance: this.instance,
+            timestamp: this.timestamp.toISOString(),
+        };
+        if (this.errorCode) {
+            problem.errorCode = this.errorCode;
+        }
+        if (this.service) {
+            problem.service = this.service;
+        }
+        if (this.details) {
+            problem.detail = this.details;
+        }
+        if (this.validationErrors) {
+            problem.validationErrors = this.validationErrors;
+        }
+        return problem;
+    }
 }
 exports.AppError = AppError;