@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/lib/core/Container.js

@@ -0,0 +1,667 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = exports.ownerSymbol = exports.containerSymbol = void 0;
+exports.registerTeardownHook = registerTeardownHook;
+const DependencyInjectionContainer_js_1 = require("../ioc/DependencyInjectionContainer.js");
+const BaseObject_js_1 = require("../base/BaseObject.js");
+const ConstructorSymbol_js_1 = require("../ioc/ConstructorSymbol.js");
+const LoadObjectOptions_js_1 = require("../../options/LoadObjectOptions.js");
+const Resolvers_js_1 = require("../ioc/Resolvers.js");
+const ObjectLifetime_js_1 = require("../ioc/ObjectLifetime.js");
+const ConfigurableRecordsInjection_js_1 = require("../base/internal/ConfigurableRecordsInjection.js");
+const DTO_js_1 = require("../dto/DTO.js");
+const ObjectInjection_js_1 = require("../base/internal/ObjectInjection.js");
+const Accept_js_1 = require("../../decorators/dto/Accept.js");
+const ListModules_js_1 = require("../ioc/ListModules.js");
+const url_1 = require("url");
+const Utils_js_1 = require("../ioc/Utils.js");
+const ModuleInitialization_js_1 = require("../base/internal/ModuleInitialization.js");
+const ObjectStartup_js_1 = require("../base/internal/ObjectStartup.js");
+const LifecycleErrorReporter_js_1 = require("../foundation/LifecycleErrorReporter.js");
+const ThrowWarning_js_1 = require("../foundation/ThrowWarning.js");
+const IsSubclassOf_1 = require("@lakutata/utils/IsSubclassOf");
+const ObjectDestroyedException_js_1 = require("../../exceptions/ObjectDestroyedException.js");
+const As_1 = require("@lakutata/utils/As");
+const IsEmptyObject_1 = require("@lakutata/utils/IsEmptyObject");
+const ObjectWeakRefs_js_1 = require("../ioc/ObjectWeakRefs.js");
+exports.containerSymbol = Symbol('LAKUTATA.DI.CONTAINER.SYMBOL');
+exports.ownerSymbol = Symbol('LAKUTATA.DI.OWNER.SYMBOL');
+//The hooks run before the teardown of a container, by container
+const teardownHooks = new WeakMap();
+/**
+ * Register a hook run when a container starts its teardown, before its scopes and objects are destroyed
+ * (an entrypoint stops receiving requests and waits for the requests in progress there), returns its unregistration
+ * @param container
+ * @param hook
+ */
+function registerTeardownHook(container, hook) {
+    let hooks = teardownHooks.get(container);
+    if (!hooks)
+        teardownHooks.set(container, hooks = new Set());
+    hooks.add(hook);
+    return () => void hooks.delete(hook);
+}
+/**
+ * The dependency injection container: it registers the classes of the objects (components, providers, modules, any
+ * {@link BaseObject}), creates them on demand with their lifetime and destroys them with itself.
+ *
+ * An object is created asynchronously: its `@Inject` properties are resolved from the container, its `@Configurable`
+ * properties get their configured values (validated and transformed by their schemas), then its `init()` runs; the
+ * promise of `get()`, `set()` or `build()` settles once `init()` has completed. The lifetime of the class decides
+ * which instance is returned:
+ * - `@Singleton` (components, modules): one instance, held by the container which registered the class.
+ * - `@Scoped` (providers): one instance per scope (see {@link Container.createScope}), such as per request.
+ * - `@Transient` ({@link BaseObject}): a new instance on each request.
+ *
+ * The applications rarely create a container: the {@link Application} owns the root one, each object owns a child
+ * container tracking the objects it creates (destroyed with it), and the modules and components reach theirs through
+ * their protected `container` property. A container created with `new Container()` is a root container, to use the
+ * objects without an application (tests, scripts).
+ * @example
+ * ```typescript
+ * import {Component, Container, DTO, Provider} from 'lakutata'
+ * import {Configurable, Inject} from 'lakutata/decorator/di'
+ *
+ * class Greeter extends Provider {
+ *     //'Hello' unless configured
+ *     @Configurable(DTO.String())
+ *     protected readonly greeting: string = 'Hello'
+ *
+ *     public greet(name: string): string {
+ *         return `${this.greeting}, ${name}`
+ *     }
+ * }
+ *
+ * class Reception extends Component {
+ *     @Inject('greeter')
+ *     protected readonly greeter!: Greeter
+ *
+ *     public welcome(name: string): string {
+ *         return this.greeter.greet(name)
+ *     }
+ * }
+ *
+ * const container: Container = new Container()
+ * await container.registerNamed('greeter', Greeter, {greeting: 'Welcome'})
+ * const reception: Reception = await container.set(Reception)
+ * console.log(reception.welcome('Ada')) //Welcome, Ada
+ * await container.destroy()
+ * ```
+ */
+class Container {
+    #dic;
+    /**
+     * Removes the weak reference of a garbage collected sub object container from its parent
+     * @private
+     */
+    static #releasedContainerRegistry = new FinalizationRegistry(({ refs, ref }) => refs.delete(ref));
+    /**
+     * Sub scopes are held strongly, a scope lives until it is destroyed explicitly or together with its parent
+     * @private
+     */
+    #subScopeSet;
+    /**
+     * Containers of sub objects are held weakly, they live as long as their owner objects
+     * @private
+     */
+    #subObjectContainerRefs;
+    #selfRef;
+    #destroyed;
+    #destroyPromise;
+    /**
+     * Whether current container is a scope (the root container or one created by createScope()),
+     * an object's own container is not a scope, it only tracks the objects created by that object
+     * @private
+     */
+    #isScope;
+    /**
+     * Create a container. Without parent, a root container; with a parent, a container whose registrations fall back
+     * to the parent's, destroyed together with it.
+     * @param parent The parent container, none for a root container.
+     * @param owner The object owning the container (the framework gives each object its own container).
+     */
+    constructor(parent, owner) {
+        /**
+         * Sub scopes are held strongly, a scope lives until it is destroyed explicitly or together with its parent
+         * @private
+         */
+        this.#subScopeSet = new Set();
+        /**
+         * Containers of sub objects are held weakly, they live as long as their owner objects
+         * @private
+         */
+        this.#subObjectContainerRefs = new Set();
+        this.#selfRef = new WeakRef(this);
+        this.#destroyed = false;
+        /**
+         * The names registered by this container itself (not by its parents); a singleton is resolved by the container
+         * which registered it, a scoped object by the nearest scope.
+         * @protected
+         */
+        this.injectionNames = new Set();
+        this.parent = parent;
+        this.#isScope = !parent;
+        this.#dic = parent ? parent.#dic.createScope() : (0, DependencyInjectionContainer_js_1.createContainer)({
+            //strict must be false
+            strict: false
+        });
+        if (this.parent)
+            Container.#releasedContainerRegistry.register(this, {
+                refs: this.parent.#subObjectContainerRefs,
+                ref: this.#selfRef
+            });
+        this.#attachToParent();
+        this.#dic.register(exports.containerSymbol, (0, Resolvers_js_1.asValue)(this));
+        if (owner)
+            this.#dic.register(exports.ownerSymbol, (0, Resolvers_js_1.asValue)(new WeakRef(owner)));
+    }
+    /**
+     * Let the parent track current container, so it is destroyed together with its parent
+     * @private
+     */
+    #attachToParent() {
+        if (!this.parent)
+            return;
+        if (this.#isScope) {
+            this.parent.#subScopeSet.add(this);
+        }
+        else {
+            this.parent.#subObjectContainerRefs.add(this.#selfRef);
+        }
+    }
+    /**
+     * Create the resolver of a registration
+     * @param target
+     * @private
+     */
+    #createResolver(target) {
+        return (0, Resolvers_js_1.asClass)(target, (0, As_1.As)(this.buildResolverOptions(target)));
+    }
+    /**
+     * Throw if current container has been destroyed (or is being destroyed)
+     * @private
+     */
+    #assertNotDestroyed() {
+        if (this.#destroyed)
+            throw new ObjectDestroyedException_js_1.ObjectDestroyedException('The container has been destroyed');
+    }
+    /**
+     * Get the nearest scope, starting from current container
+     * @private
+     */
+    #nearestScope() {
+        let container = this;
+        while (!container.#isScope && container.parent)
+            container = container.parent;
+        return container;
+    }
+    /**
+     * Get the root container, the one without parent
+     * @private
+     */
+    #root() {
+        let container = this;
+        while (container.parent)
+            container = container.parent;
+        return container;
+    }
+    /**
+     * Stop being tracked by the parent
+     * @private
+     */
+    #detachFromParent() {
+        if (!this.parent)
+            return;
+        this.parent.#subScopeSet.delete(this);
+        this.parent.#subObjectContainerRefs.delete(this.#selfRef);
+    }
+    /**
+     * Destroy an object of the container during its teardown: its `beforeDestroy()`, the objects it created, then its
+     * `destroy()`. Never throws: the errors are reported through the application's logger.
+     * @param instance The object to destroy.
+     * @returns Resolves once the object is destroyed.
+     * @protected
+     */
+    async disposer(instance) {
+        try {
+            await instance.getMethod(BaseObject_js_1.__destroy, false)();
+        }
+        catch (e) {
+            //Cascaded destruction never throws, errors are reported instead
+            (0, LifecycleErrorReporter_js_1.reportDestroyError)(e, instance.className);
+        }
+    }
+    /**
+     * The options of the resolver of a class: the lifetime declared by its decorators (`@Singleton`, `@Scoped`,
+     * `@Transient`) and its disposer ({@link Container.disposer}).
+     * @param target The class to register or build.
+     * @returns The resolver options.
+     * @protected
+     */
+    buildResolverOptions(target) {
+        const objectLifetime = (0, ObjectLifetime_js_1.getObjectLifetime)(target);
+        return {
+            lifetime: objectLifetime,
+            dispose: (instance) => this.disposer(instance)
+        };
+    }
+    /**
+     * Give an object just created by the container its registration name and its options: the options it was
+     * registered with, overridden by the ones requested. An object already created (a cached singleton or scoped
+     * instance) is returned as it is, the options requested being ignored with a warning outside production.
+     * @param resolved The object, or the promise of its asynchronous construction.
+     * @param registrationName The name (or class symbol) the object was requested by.
+     * @param configurableRecords The options requested for the object.
+     * @returns The object, once constructed.
+     * @protected
+     */
+    async processResolved(resolved, registrationName, configurableRecords = {}) {
+        //Only a newly created object gets its id and configurable records, a cached one is already initialized
+        const isSubBaseObject = (0, IsSubclassOf_1.isSubclassOf)(resolved?.constructor, BaseObject_js_1.BaseObject);
+        const isNewSubBaseObject = isSubBaseObject && (0, ConfigurableRecordsInjection_js_1.getRegistrationNameFromInstance)((0, As_1.As)(resolved)) === undefined;
+        if (isSubBaseObject && !isNewSubBaseObject && !(0, IsEmptyObject_1.isEmptyObject)(configurableRecords) && process.env.NODE_ENV !== 'production') {
+            (0, ThrowWarning_js_1.throwWarning)(`The configuration passed for the already created object "${(0, As_1.As)(resolved).className}" is ignored. Use a scoped or transient object to get an instance with its own configuration.`);
+        }
+        if (isNewSubBaseObject) {
+            const presetConfigurableRecords = (0, ConfigurableRecordsInjection_js_1.getConfigurableRecords)((0, As_1.As)(resolved.constructor), registrationName);
+            //set id into object instance
+            (0, ConfigurableRecordsInjection_js_1.setIdToInstance)((0, As_1.As)(resolved), registrationName);
+            //set configurable records into object instance
+            (0, ConfigurableRecordsInjection_js_1.setConfigurableRecordsToInstance)((0, As_1.As)(resolved), { ...presetConfigurableRecords, ...configurableRecords });
+        }
+        return Promise.resolve(resolved);
+    }
+    /**
+     * Build the registration of an object declaration: its name is its id (the name it is declared under) or, without
+     * id, a symbol of its class; its other options are kept as the options it is created with.
+     * @param options The object declaration.
+     * @returns The registration, keyed by its name.
+     * @protected
+     */
+    buildNameAndRegistrationPairFromOptions(options) {
+        const pair = {};
+        const id = options[LoadObjectOptions_js_1.OBJECT_ID] ? options[LoadObjectOptions_js_1.OBJECT_ID] : (0, ConstructorSymbol_js_1.constructorSymbol)(options.class);
+        const configurableRecords = { ...options, class: void (0) };
+        delete configurableRecords.id;
+        delete configurableRecords.class;
+        (0, ConfigurableRecordsInjection_js_1.setConfigurableRecords)(options.class, id, configurableRecords);
+        pair[id] = this.#createResolver(options.class);
+        return pair;
+    }
+    /**
+     * Build the registrations of the classes found by a glob pattern: each file matched is imported, and each of its
+     * exports which is a {@link BaseObject} subclass is registered under the symbol of its class.
+     * @param glob The glob pattern of the files to import, relative to the working directory (the aliases are not
+     * replaced in it).
+     * @returns The registrations, keyed by their class symbols.
+     * @throws {Error} When a file matched fails to import (its error as the cause).
+     * @protected
+     */
+    async buildNameAndRegistrationPairFromGlob(glob) {
+        const pairs = await Promise.all((0, ListModules_js_1.listModules)(glob).map(async (moduleDescriptor) => {
+            let importResult;
+            try {
+                importResult = await Promise.resolve(`${(0, url_1.pathToFileURL)(moduleDescriptor.path).toString()}`).then(s => __importStar(require(s)));
+            }
+            catch (error) {
+                throw new Error(`The file ${moduleDescriptor.path} matched by "${glob}" cannot be imported: ${error?.message ?? error}`, { cause: error });
+            }
+            const pair = {};
+            for (const exportObj of Object.values(importResult)) {
+                if ((0, Utils_js_1.isClass)(exportObj) && (0, IsSubclassOf_1.isSubclassOf)(exportObj, BaseObject_js_1.BaseObject))
+                    pair[(0, ConstructorSymbol_js_1.constructorSymbol)(exportObj)] = this.#createResolver((0, As_1.As)(exportObj));
+            }
+            return pair;
+        }));
+        return Object.assign({}, ...pairs);
+    }
+    /**
+     * The object owning the container (the one whose container it is, or the owner of the container a scope was
+     * created from).
+     * @returns The owner, or undefined for a container without owner or whose owner was garbage collected.
+     */
+    owner() {
+        const owner = this.#dic.resolve(exports.ownerSymbol, { allowUnregistered: true });
+        return owner ? owner.deref() : undefined;
+    }
+    /**
+     * Register objects in the container, without creating them: a class is registered under the symbol of its class
+     * (got by its class), a declaration with an id under its id (got by its name) with its options, a glob pattern
+     * registers the classes of the files it matches. A name registered again replaces the previous registration.
+     * @param options The classes, declarations (`{class, ...options}`) and glob patterns to register.
+     * @returns Resolves once registered (the glob patterns imported).
+     * @throws {InvalidMethodAcceptException} When an item is neither a class, a declaration nor a glob pattern.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     * @throws {Error} When a file matched by a glob pattern fails to import.
+     */
+    async load(options) {
+        this.#assertNotDestroyed();
+        let pair = {};
+        const buildNameAndRegistrationPairFromGlobPromises = [];
+        options.forEach((value) => {
+            if (typeof value === 'string') {
+                //glob
+                buildNameAndRegistrationPairFromGlobPromises.push(this.buildNameAndRegistrationPairFromGlob(value));
+            }
+            else if ((0, Utils_js_1.isClass)((0, As_1.As)(value))) {
+                const loadObjectOptions = { class: (0, As_1.As)(value) };
+                pair = { ...pair, ...this.buildNameAndRegistrationPairFromOptions(loadObjectOptions) };
+            }
+            else {
+                //load options
+                const loadObjectOptions = (0, As_1.As)(value);
+                pair = { ...pair, ...this.buildNameAndRegistrationPairFromOptions(loadObjectOptions) };
+            }
+        });
+        if (buildNameAndRegistrationPairFromGlobPromises.length) {
+            const pairs = await Promise.all(buildNameAndRegistrationPairFromGlobPromises);
+            pairs.forEach((_pair) => {
+                pair = { ..._pair, ...pair };
+            });
+        }
+        if (!(0, IsEmptyObject_1.isEmptyObject)(pair)) {
+            Object.getOwnPropertyNames(pair).forEach(value => this.injectionNames.add(value));
+            Object.getOwnPropertySymbols(pair).forEach(value => this.injectionNames.add(value));
+            this.#dic.register(pair);
+        }
+    }
+    async get(inp, configurableRecords = {}) {
+        return await this.#get(inp, configurableRecords, false);
+    }
+    async getShared(inp, configurableRecords = {}) {
+        return await this.#get(inp, configurableRecords, true);
+    }
+    /**
+     * Get a registered object
+     * @param inp
+     * @param configurableRecords
+     * @param shared whether a scoped object requested with a configuration is the shared instance
+     * @private
+     */
+    async #get(inp, configurableRecords, shared) {
+        const registrationName = typeof inp === 'function' ? (0, ConstructorSymbol_js_1.constructorSymbol)(inp) : inp;
+        this.#assertNotDestroyed();
+        if (!this.#dic.hasRegistration(registrationName) && typeof inp === 'function' && (0, ObjectInjection_js_1.getObjectIsAutoload)((0, As_1.As)(inp))) {
+            //An autoloaded scoped object is registered in the nearest scope, so it is shared within the request;
+            //an autoloaded singleton in the root container, so it is shared by every object of the application
+            const lifetime = (0, As_1.As)((0, ObjectLifetime_js_1.getObjectLifetime)((0, As_1.As)(inp)));
+            const registerContainer = lifetime === 'SCOPED' ? this.#nearestScope() : lifetime === 'SINGLETON' ? this.#root() : this;
+            await registerContainer.load([{
+                    id: registrationName,
+                    class: (0, As_1.As)(inp)
+                }]);
+        }
+        const registration = this.#dic.getRegistration(registrationName);
+        const lifetime = registration?.lifetime;
+        //A scoped object requested with its own configuration is a new instance owned by the requester, it is not cached,
+        //so it never replaces the instance shared within the request (unless the shared instance is requested)
+        if (!shared && registration && lifetime === 'SCOPED' && !(0, IsEmptyObject_1.isEmptyObject)(configurableRecords)) {
+            const configured = await this.processResolved(this.#dic.build(registration), registrationName, configurableRecords);
+            (0, ObjectWeakRefs_js_1.appendObjectWeakRefs)(this.#dic, configured);
+            await (0, ObjectStartup_js_1.waitForObjectStartup)(configured);
+            return configured;
+        }
+        let resolver = this;
+        if (lifetime === 'SINGLETON') {
+            //Singletons are resolved by the container which registered them
+            while (!resolver.injectionNames.has(registrationName) && resolver.parent)
+                resolver = resolver.parent;
+        }
+        else if (lifetime === 'SCOPED') {
+            //Scoped objects are resolved by the nearest scope (one instance per request), or by the container which registered them
+            while (!resolver.injectionNames.has(registrationName) && !resolver.#isScope && resolver.parent)
+                resolver = resolver.parent;
+        }
+        resolver.#assertNotDestroyed();
+        const object = await resolver.processResolved(resolver.#dic.resolve(registrationName), registrationName, configurableRecords);
+        await this.#waitForModule(object);
+        await (0, ObjectStartup_js_1.waitForObjectStartup)(object);
+        return object;
+    }
+    /**
+     * Wait for the initialization of a module resolved for an object outside it (its objects loaded, its bootstrap
+     * run); the module itself and its objects, created by its initialization, do not wait for it
+     * @param object
+     * @private
+     */
+    async #waitForModule(object) {
+        const initialization = object?.[ModuleInitialization_js_1.MODULE_INITIALIZATION];
+        if (typeof initialization !== 'function')
+            return;
+        for (let container = this; container; container = container.parent)
+            if (container.owner() === object)
+                return;
+        await initialization.call(object);
+    }
+    has(inp) {
+        if (typeof inp === 'function')
+            return this.#dic.hasRegistration((0, ConstructorSymbol_js_1.constructorSymbol)(inp));
+        return this.#dic.hasRegistration(inp);
+    }
+    /**
+     * Register a class (unless it is registered already) and get its object, as {@link Container.get}.
+     * @param target The class.
+     * @param configurableRecords The options of the object: registered with the class when it is registered now, and
+     * requested for the object.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     * @throws {Error} When the object fails to be created.
+     */
+    async set(target, configurableRecords = {}) {
+        if (!this.has(target)) {
+            await this.load([{
+                    ...configurableRecords,
+                    class: target
+                }]);
+        }
+        return await this.get(target, {
+            ...configurableRecords
+        });
+    }
+    /**
+     * Register a class under a name, replacing a previous registration of the name, and get its object.
+     * @param name The registration name or symbol.
+     * @param target The class.
+     * @param configurableRecords The options the object is registered with.
+     * @returns The object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     * @throws {Error} When the object fails to be created.
+     */
+    async setNamed(name, target, configurableRecords = {}) {
+        await this.load([{
+                ...configurableRecords,
+                class: target,
+                [LoadObjectOptions_js_1.OBJECT_ID]: name
+            }]);
+        return await this.get(name);
+    }
+    /**
+     * Register a class by its class, without creating its object; a class registered again replaces its previous
+     * registration.
+     * @param target The class.
+     * @param configurableRecords The options its objects are created with.
+     * @returns Resolves once registered.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     */
+    async register(target, configurableRecords = {}) {
+        await this.load([{
+                ...configurableRecords,
+                class: target
+            }]);
+    }
+    /**
+     * Register a class under a name, without creating its object; a name registered again replaces its previous
+     * registration.
+     * @param name The registration name or symbol.
+     * @param target The class.
+     * @param configurableRecords The options its objects are created with.
+     * @returns Resolves once registered.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     */
+    async registerNamed(name, target, configurableRecords = {}) {
+        await this.load([{
+                ...configurableRecords,
+                class: target,
+                [LoadObjectOptions_js_1.OBJECT_ID]: name
+            }]);
+    }
+    /**
+     * Create a new object of a class without registering it, whatever its lifetime: its dependencies are injected
+     * from this container, and it is destroyed with this container (unless disposed before).
+     * @param target The class, registered or not.
+     * @param configurableRecords The options of the object.
+     * @returns The new object, once created and initialized.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     * @throws {Error} When the object fails to be created.
+     */
+    async build(target, configurableRecords = {}) {
+        this.#assertNotDestroyed();
+        const builtObject = await this.processResolved(this.#dic.build(target, this.buildResolverOptions(target)), (0, ConstructorSymbol_js_1.constructorSymbol)(target), configurableRecords);
+        (0, ObjectWeakRefs_js_1.appendObjectWeakRefs)(this.#dic, builtObject);
+        await (0, ObjectStartup_js_1.waitForObjectStartup)(builtObject);
+        return builtObject;
+    }
+    /**
+     * Create a scope: a child container holding its own instances of the scoped objects (one per scope, such as one per
+     * request), the singletons and registrations of this container being shared. The scope lives until it is destroyed
+     * explicitly, or together with this container.
+     * @returns The new scope.
+     * @throws {ObjectDestroyedException} When the container has been destroyed.
+     */
+    createScope() {
+        this.#assertNotDestroyed();
+        const scope = new Container(this, this.owner());
+        scope.#detachFromParent();
+        scope.#isScope = true;
+        scope.#attachToParent();
+        return scope;
+    }
+    /**
+     * Track this container in its parent again, so it is destroyed together with the parent (used when its owner is
+     * initialized again).
+     */
+    registerContainerToItsParent() {
+        this.#attachToParent();
+    }
+    /**
+     * Make a destroyed container usable again, when its owner is reloaded.
+     * @throws {ObjectDestroyedException} When the parent container has been destroyed (or is being destroyed).
+     */
+    revive() {
+        if (this.parent && this.parent.#destroyed)
+            throw new ObjectDestroyedException_js_1.ObjectDestroyedException('Cannot revive a container whose parent container has been destroyed');
+        this.#destroyed = false;
+        this.#destroyPromise = undefined;
+        this.#attachToParent();
+    }
+    /**
+     * Drop the cached instance of a registration, so the next request creates a new one; nothing happens when the
+     * cached instance is not the one given.
+     * @param name The registration name or symbol.
+     * @param instance The instance to drop.
+     */
+    forget(name, instance) {
+        const cached = this.#dic.cache.get(name);
+        if (cached && cached.value === instance)
+            this.#dic.cache.delete(name);
+    }
+    /**
+     * Destroy the container's objects and scopes, the container remaining usable: the teardown hooks run (the
+     * entrypoints stop), then the scopes and the containers of the objects are destroyed, then the cached objects and
+     * the transient objects still alive. Never throws: the errors are reported through the application's logger, and a
+     * failing object does not stop the teardown of the others.
+     * @returns Resolves once everything is destroyed.
+     */
+    async clear() {
+        //Every step always runs to the end, a failing object never stops the teardown of the others
+        const hooks = teardownHooks.get(this);
+        if (hooks?.size) {
+            const results = await Promise.allSettled([...hooks].map((hook) => hook()));
+            results.forEach((result) => result.status === 'rejected' && (0, LifecycleErrorReporter_js_1.reportDestroyError)(result.reason));
+        }
+        const subContainers = [...this.#subScopeSet];
+        this.#subObjectContainerRefs.forEach((ref) => {
+            const subContainer = ref.deref();
+            if (subContainer)
+                subContainers.push(subContainer);
+        });
+        await Promise.all(subContainers.map((subContainer) => subContainer.destroy()));
+        try {
+            await this.#dic.dispose();
+        }
+        catch (e) {
+            (0, LifecycleErrorReporter_js_1.reportDestroyError)(e);
+        }
+        const transients = [];
+        (0, ObjectWeakRefs_js_1.getObjectWeakRefs)(this.#dic).forEach((ref) => {
+            const transient = ref.deref();
+            if (transient)
+                transients.push(transient);
+        });
+        await Promise.all(transients.map((transient) => this.disposer(transient)));
+        (0, ObjectWeakRefs_js_1.clearObjectWeakRefs)(this.#dic);
+    }
+    /**
+     * Destroy the container: as {@link Container.clear}, then the container refuses any further request with an
+     * {@link ObjectDestroyedException}. A concurrent or repeated call waits for the same teardown.
+     * @returns Resolves once the container is destroyed.
+     */
+    async destroy() {
+        //A teardown already in progress is awaited, not skipped
+        if (this.#destroyPromise)
+            return await this.#destroyPromise;
+        this.#destroyed = true;
+        this.#detachFromParent();
+        this.#destroyPromise = this.clear();
+        await this.#destroyPromise;
+    }
+}
+exports.Container = Container;
+__decorate([
+    (0, Accept_js_1.Accept)(DTO_js_1.DTO.Array(DTO_js_1.DTO.Alternatives(LoadObjectOptions_js_1.LoadObjectOptions.Schema(), DTO_js_1.DTO.Class(() => BaseObject_js_1.BaseObject), DTO_js_1.DTO.Glob()))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], Container.prototype, "load", null);