@lakutata/core 3.1.0 → 3.1.4

package/README.md

@@ -169,6 +169,7 @@ await container.destroy()
 | `Before`, `After` | `lakutata/decorator/asst` | Functions run before and after a method |
 | `PaginationSearchDTO`, `PaginationResultDTO`, `paginator`, `FlexibleDTO`, `toJsonSchema`, `fromJsonSchema` | `lakutata/dtos` | Pagination, open DTOs and JSON Schema conversion |
 | `ConsoleLogger`, `ILogger` | `@lakutata/core/com/logger` | The logger interface and its console implementation |
+| `IInterfaceListening`, `IInterfaceListener`, `IInterfaceListenOptions`, `IListeningAddress`, `NetworkInterfaceSelector` | `lakutata` | The contract of the listening on network interfaces, which the entrypoints use for their `interface` option and `@lakutata/netif` implements (types only) |
 
 The typings document each declaration with examples.
 

package/README.zh-CN.md

@@ -158,6 +158,7 @@ await container.destroy()
 | `Before`、`After` | `lakutata/decorator/asst` | 在方法之前和之后执行的函数 |
 | `PaginationSearchDTO`、`PaginationResultDTO`、`paginator`、`FlexibleDTO`、`toJsonSchema`、`fromJsonSchema` | `lakutata/dtos` | 分页、接受任意字段的 DTO、JSON Schema 转换 |
 | `ConsoleLogger`、`ILogger` | `@lakutata/core/com/logger` | 日志记录器接口及其控制台实现 |
+| `IInterfaceListening`、`IInterfaceListener`、`IInterfaceListenOptions`、`IListeningAddress`、`NetworkInterfaceSelector` | `lakutata` | 按网口监听的接口：入口的 `interface` 选项通过它监听，`@lakutata/netif` 实现了它（只有类型） |
 
 类型声明中的每一项都附有说明和示例。
 

package/dist/cjs/decorators/dto/Expect.d.ts

@@ -5,7 +5,8 @@ import { Schema } from '../../lib/validation/types/Schema.js';
  * Declare the schema of a property of a DTO class. The DTO validates the property against it when it is constructed
  * (the whole object at once: defaults applied, the keys without schema removed unless the class has an
  * `@IndexSignature`), and each time the property, or a value nested in it, is changed afterwards (the change is undone
- * when invalid). The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
+ * when invalid). With `DTO.Any()`, an object of another class the property holds is given as it is, not watched: no
+ * change of it can be invalid. The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
  * actions' input validation. Subclasses inherit the property schemas, and may declare a property again to replace its
  * schema. Ignored on a symbol property or on a class which is not a DTO.
  * @param schema The schema of the property, built with the static methods of `DTO` (`DTO.String().required()`); a

package/dist/cjs/decorators/dto/Expect.js

@@ -6,7 +6,8 @@ const ObjectSchemaValidation_js_1 = require("../../lib/dto/ObjectSchemaValidatio
  * Declare the schema of a property of a DTO class. The DTO validates the property against it when it is constructed
  * (the whole object at once: defaults applied, the keys without schema removed unless the class has an
  * `@IndexSignature`), and each time the property, or a value nested in it, is changed afterwards (the change is undone
- * when invalid). The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
+ * when invalid). With `DTO.Any()`, an object of another class the property holds is given as it is, not watched: no
+ * change of it can be invalid. The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
  * actions' input validation. Subclasses inherit the property schemas, and may declare a property again to replace its
  * schema. Ignored on a symbol property or on a class which is not a DTO.
  * @param schema The schema of the property, built with the static methods of `DTO` (`DTO.String().required()`); a

package/dist/cjs/exports/Core.d.ts

@@ -90,4 +90,5 @@ export * from '../types/ModuleOptions.js';
  */
 export * from '../interfaces/IBaseObjectConstructor.js';
 export * from '../interfaces/ILogger.js';
+export * from '../interfaces/IInterfaceListening.js';
 export * from '../interfaces/IConstructor.js';

package/dist/cjs/exports/Core.js

@@ -121,6 +121,7 @@ __exportStar(require("../types/ModuleOptions.js"), exports);
  */
 __exportStar(require("../interfaces/IBaseObjectConstructor.js"), exports);
 __exportStar(require("../interfaces/ILogger.js"), exports);
+__exportStar(require("../interfaces/IInterfaceListening.js"), exports);
 __exportStar(require("../interfaces/IConstructor.js"), exports);
 
 //The default of the entry: the entry itself (scripts/package-build/cjs-package.mjs)

package/dist/cjs/interfaces/IInterfaceListening.d.ts

@@ -0,0 +1,159 @@
+import type { Server } from 'node:net';
+/**
+ * A network interface, as an implementation of {@link IInterfaceListening} takes it: its name (`'eth1'`; on Windows the
+ * name of the network connection), its hardware address (`{mac: '52:54:00:12:34:56'}`) or its index (`{index: 3}`).
+ */
+export type NetworkInterfaceSelector = string | {
+    /**
+     * The hardware address of the interface.
+     */
+    mac: string;
+} | {
+    /**
+     * The index of the interface.
+     */
+    index: number;
+};
+/**
+ * An address a listener of a network interface can be reached at.
+ */
+export interface IListeningAddress {
+    /**
+     * The address (an IPv6 address without its scope).
+     */
+    address: string;
+    /**
+     * `'IPv4'` or `'IPv6'`.
+     */
+    family: 'IPv4' | 'IPv6';
+    /**
+     * The port.
+     */
+    port: number;
+    /**
+     * IPv6 only: the scope of the address (the index of the interface for a link-local one), 0 for a global one.
+     */
+    scopeid?: number;
+}
+/**
+ * The options of {@link IInterfaceListening.listenOnAll}.
+ */
+export interface IInterfaceListenOptions {
+    /**
+     * The port; 0 lets the system choose one (for one interface only).
+     */
+    port: number;
+    /**
+     * The families listened on.
+     * @default 'both'
+     */
+    family?: 'IPv4' | 'IPv6' | 'both';
+    /**
+     * Refuse to listen where the connections reaching the addresses of the interface through another interface cannot
+     * be refused, and stop listening while they cannot. An implementation that never refuses them throws.
+     * @default false
+     */
+    strict?: boolean;
+}
+/**
+ * The listener of a network interface for a server: it accepts the connections of the interface and gives them to the
+ * server, whatever the addresses of the interface, again when they change and when the interface is unplugged and
+ * plugged back. The server itself does not listen. The `InterfaceListener` of `@lakutata/netif` implements it.
+ */
+export interface IInterfaceListener {
+    /**
+     * The interface listened on: its name (`undefined` while it does not exist), and whether it is the loopback one.
+     */
+    readonly networkInterface: {
+        readonly name: string | undefined;
+        readonly loopback: boolean;
+    };
+    /**
+     * The port, `undefined` until a port 0 is given one by the system.
+     */
+    readonly port: number | undefined;
+    /**
+     * The addresses it can be reached at now: none while the interface does not exist or has no address.
+     */
+    readonly addresses: IListeningAddress[];
+    /**
+     * Whether the interface is listened on now.
+     */
+    readonly listening: boolean;
+    /**
+     * Whether the system refuses the connections that reach the addresses of the interface through another interface.
+     */
+    readonly enforced: boolean;
+    /**
+     * Why `enforced` is `false`, when it is.
+     */
+    readonly reason: string | undefined;
+    /**
+     * Whether it was closed.
+     */
+    readonly closed: boolean;
+    /**
+     * Stop listening; the connections established are left to the server.
+     */
+    close(): Promise<void>;
+    /**
+     * The interface is listened on, again after a change.
+     * @param event `'listening'`.
+     * @param listener Called without argument.
+     */
+    on(event: 'listening', listener: () => void): this;
+    /**
+     * A failure of listening again, retried by the listener; with `strict`, the guarantee lost.
+     * @param event `'error'`.
+     * @param listener Called with the error.
+     */
+    on(event: 'error', listener: (error: Error) => void): this;
+    /**
+     * `enforced` changed.
+     * @param event `'enforced'`.
+     * @param listener Called with its new value.
+     */
+    on(event: 'enforced', listener: (enforced: boolean) => void): this;
+    /**
+     * The listener was closed.
+     * @param event `'close'`.
+     * @param listener Called without argument.
+     */
+    on(event: 'close', listener: () => void): this;
+    /**
+     * Remove a listener of an event.
+     * @param event The event.
+     * @param listener The listener given to `on()`.
+     */
+    off(event: 'listening' | 'error' | 'enforced' | 'close', listener: (...args: any[]) => void): this;
+}
+/**
+ * Listening on network interfaces instead of addresses: what the entrypoints use for their `interface` option. The
+ * package `@lakutata/netif` implements it, and is the one used by default; another implementation is given in the
+ * `interfaceListening` option of the entrypoints.
+ * @example
+ * ```typescript
+ * import type {IInterfaceListener, IInterfaceListening} from 'lakutata'
+ * import {listenOnAll} from '@lakutata/netif'
+ *
+ * //An implementation that writes each listener made before giving it to the entrypoint
+ * const logged: IInterfaceListening = {
+ *     listenOnAll: async (selectors, server, options): Promise<IInterfaceListener[]> => {
+ *         const listeners: IInterfaceListener[] = await listenOnAll(selectors, server, options)
+ *         for (const listener of listeners) console.log(listener.networkInterface.name, listener.addresses)
+ *         return listeners
+ *     }
+ * }
+ * ```
+ */
+export interface IInterfaceListening {
+    /**
+     * Listen on interfaces for a server, one listener by interface; when one cannot be listened on, the others are
+     * closed and the error is thrown. An interface that does not exist yet is listened on once it appears.
+     * @param selectors The interfaces; several need a port other than 0.
+     * @param server The server the connections are given to.
+     * @param options The port, the families, and whether the other interfaces must be refused.
+     * @returns The listeners, in the order of the interfaces.
+     */
+    listenOnAll(selectors: NetworkInterfaceSelector | NetworkInterfaceSelector[], server: Server, options: IInterfaceListenOptions): Promise<IInterfaceListener[]>;
+}

package/dist/cjs/interfaces/IInterfaceListening.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/base/internal/ConfigurableRecordsInjection.d.ts

@@ -1,18 +1,18 @@
 import { BaseObject } from '../BaseObject.js';
+import { type Resolver } from '../../ioc/Resolvers.js';
 /**
- * Set configurable records to target constructor with its registration name
- * @param target
- * @param registrationName
+ * Set configurable records to a registration (the options it was declared with)
+ * @param registration
  * @param configurableRecords
  * @constructor
  */
-export declare function setConfigurableRecords<ClassConstructor extends typeof BaseObject>(target: ClassConstructor, registrationName: string | symbol, configurableRecords: Record<string, any>): void;
+export declare function setConfigurableRecords(registration: Resolver<any>, configurableRecords: Record<string, any>): void;
 /**
- * Get configurable records from target constructor by its registration name
- * @param target
+ * Get configurable records from a registration
+ * @param registration
  * @constructor
  */
-export declare function getConfigurableRecords<ClassConstructor extends typeof BaseObject>(target: ClassConstructor, registrationName: string | symbol): Record<string, any>;
+export declare function getConfigurableRecords(registration: Resolver<any> | null): Record<string, any>;
 /**
  * Set id to instance
  * @param target

package/dist/cjs/lib/base/internal/ConfigurableRecordsInjection.js

@@ -10,28 +10,24 @@ exports.getConfigurableRecordsFromInstance = getConfigurableRecordsFromInstance;
 const DIMetadataKey_js_1 = require("../../../constants/DIMetadataKey.js");
 const ConstructorSymbol_js_1 = require("../../ioc/ConstructorSymbol.js");
 const As_1 = require("@lakutata/utils/As");
+//The configurable records of the registrations, by resolver: each container keeps the options of its own registrations
+const registrationRecords = new WeakMap();
 /**
- * Set configurable records to target constructor with its registration name
- * @param target
- * @param registrationName
+ * Set configurable records to a registration (the options it was declared with)
+ * @param registration
  * @param configurableRecords
  * @constructor
  */
-function setConfigurableRecords(target, registrationName, configurableRecords) {
-    if (Reflect.hasOwnMetadata(registrationName, target))
-        Reflect.deleteMetadata(registrationName, target);
-    Reflect.defineMetadata(registrationName, configurableRecords, target);
+function setConfigurableRecords(registration, configurableRecords) {
+    registrationRecords.set(registration, configurableRecords);
 }
 /**
- * Get configurable records from target constructor by its registration name
- * @param target
+ * Get configurable records from a registration
+ * @param registration
  * @constructor
  */
-function getConfigurableRecords(target, registrationName) {
-    const configurableRecords = Reflect.getOwnMetadata(registrationName, target);
-    if (configurableRecords)
-        return configurableRecords;
-    return {};
+function getConfigurableRecords(registration) {
+    return (registration && registrationRecords.get(registration)) ?? {};
 }
 /**
  * Set id to instance

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

@@ -305,7 +305,8 @@ class Container {
             (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);
+            //The options of the registration in effect here (a child container's registration shadows its parent's)
+            const presetConfigurableRecords = (0, ConfigurableRecordsInjection_js_1.getConfigurableRecords)(this.#dic.getRegistration(registrationName));
             //set id into object instance
             (0, ConfigurableRecordsInjection_js_1.setIdToInstance)((0, As_1.As)(resolved), registrationName);
             //set configurable records into object instance
@@ -326,8 +327,8 @@ class Container {
         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);
+        (0, ConfigurableRecordsInjection_js_1.setConfigurableRecords)(pair[id], configurableRecords);
         return pair;
     }
     /**

package/dist/cjs/lib/dto/DTO.d.ts

@@ -45,7 +45,9 @@ export declare class DTO extends DataValidator {
      * Create a DTO from its data, validated against the class schema: the defaults applied, the keys without schema
      * removed (unless the class has an `@IndexSignature`). The instance then validates each change of a property, or
      * of a value nested in it (an array, an object): an invalid change throws an `InvalidValueException` and is
-     * undone.
+     * undone. A property accepting any value (`DTO.Any()`, or an index signature `DTO.Any()`) gives the objects of
+     * other classes it holds as they are, since no change of theirs can be invalid: their getters, their private fields
+     * and their identity are those of the object itself.
      * @param props The data of the DTO. Default: no data (`{}`).
      * @throws {InvalidValueException} When the data does not match the class schema.
      */

package/dist/cjs/lib/dto/DTO.js

@@ -94,6 +94,55 @@ function getPropertySchema(instance, propertyKey) {
     schemas.set(propertyKey, schema);
     return schema;
 }
+/**
+ * Whether the properties of a DTO accept any value, per DTO class
+ */
+const anyValuePropertyCache = new WeakMap();
+/**
+ * Whether a schema accepts any value: an any schema without rule, value list, condition or external validation, so no
+ * change of a value it holds can fail validation
+ * @param schema
+ */
+function acceptsAnything(schema) {
+    if (!schema || schema.type !== 'any' || schema._rules.length || schema._valids || schema._invalids)
+        return false;
+    const terms = schema.$_terms;
+    return !['whens', 'externals'].some((term) => Array.isArray(terms[term]) && terms[term].length > 0);
+}
+/**
+ * Whether a property of a DTO accepts any value: declared with `DTO.Any()`, or undeclared and matched by an index
+ * signature `DTO.Any()` (the transport objects of a context)
+ * @param instance
+ * @param propertyKey
+ */
+function acceptsAnyValue(instance, propertyKey) {
+    if (typeof propertyKey !== 'string')
+        return false;
+    const properties = (0, ObjectSchemaValidation_js_1.getCachedDTOSchema)(anyValuePropertyCache, (0, ObjectConstructor_1.objectConstructor)(instance), () => new Map());
+    let accepts = properties.get(propertyKey);
+    if (accepts !== undefined)
+        return accepts;
+    const objectSchema = (0, As_1.As)(getObjectSchema(instance));
+    const child = (objectSchema.$_terms.keys || []).find(({ key }) => key === propertyKey);
+    //An undeclared property: the first pattern matching its key (the index signature)
+    const pattern = child ? undefined : (objectSchema.$_terms.patterns || []).find((each) => each.regex
+        ? each.regex.test(propertyKey)
+        : !each.schema.validate(propertyKey).error);
+    accepts = acceptsAnything(child ? child.schema : pattern?.rule);
+    properties.set(propertyKey, accepts);
+    return accepts;
+}
+/**
+ * Whether an object is plain data: an array, an object literal, or an object without prototype (an instance of a
+ * subclass of Array or Object, and the objects of another realm, count as objects of other classes)
+ * @param value
+ */
+function isPlainData(value) {
+    const constructor = value.constructor;
+    if (constructor === Object || constructor === Array)
+        return true;
+    return constructor === undefined && Object.getPrototypeOf(value) === null;
+}
 /**
  * Validate property value (only the property when the properties are validated independently)
  * @param instance
@@ -160,8 +209,10 @@ function propertyState(target, prop) {
  * @param prop
  * @param receiver
  * @param validateFn
+ * @param acceptsAny Whether a property of the DTO holding the value accepts any value
+ * @param ownerKey The property of the DTO holding the value
  */
-function dynamicProxyProperty(target, prop, receiver, validateFn) {
+function dynamicProxyProperty(target, prop, receiver, validateFn, acceptsAny, ownerKey) {
     const propertyValue = Reflect.get(target, prop, receiver);
     if (!propertyValue)
         return propertyValue;
@@ -190,6 +241,11 @@ function dynamicProxyProperty(target, prop, receiver, validateFn) {
             apply: (method, _thisArg, args) => Reflect.apply(method, target, args)
         });
     }
+    //An object of another class held by a property accepting any value is given as it is: no change of it can be
+    //refused, and a proxy would break the getters reading its private fields, the internal slots of the built-ins (the
+    //size of a Map) and its identity
+    if (acceptsAny?.(ownerKey) && !isPlainData(propertyValue))
+        return propertyValue;
     return new Proxy(propertyValue, {
         set(target, p, value, receiver) {
             const state = propertyState(target, p);
@@ -204,7 +260,7 @@ function dynamicProxyProperty(target, prop, receiver, validateFn) {
             }
         },
         get(target, p, receiver) {
-            return dynamicProxyProperty(target, p, receiver, validateFn);
+            return dynamicProxyProperty(target, p, receiver, validateFn, acceptsAny, ownerKey);
         },
         deleteProperty: (target, prop) => {
             const state = propertyState(target, prop);
@@ -262,12 +318,22 @@ let DTO = DTO_1 = class DTO extends DataValidator_js_1.DataValidator {
      * Create a DTO from its data, validated against the class schema: the defaults applied, the keys without schema
      * removed (unless the class has an `@IndexSignature`). The instance then validates each change of a property, or
      * of a value nested in it (an array, an object): an invalid change throws an `InvalidValueException` and is
-     * undone.
+     * undone. A property accepting any value (`DTO.Any()`, or an index signature `DTO.Any()`) gives the objects of
+     * other classes it holds as they are, since no change of theirs can be invalid: their getters, their private fields
+     * and their identity are those of the object itself.
      * @param props The data of the DTO. Default: no data (`{}`).
      * @throws {InvalidValueException} When the data does not match the class schema.
      */
     constructor(props = {}) {
         super();
+        //Whether each property accepts any value, remembered by the instance once known
+        let accepting;
+        const acceptsAny = (key) => {
+            if (typeof key !== 'string')
+                return false;
+            accepting ??= Object.create(null);
+            return accepting[key] ??= acceptsAnyValue(this, key);
+        };
         //Create DTO proxy object
         const DTOInstanceProxy = new Proxy(this, {
             set: (target, prop, value, receiver) => {
@@ -283,7 +349,7 @@ let DTO = DTO_1 = class DTO extends DataValidator_js_1.DataValidator {
                 else {
                     validatePropertyValue(this, p, Reflect.get(target, p));
                 }
-            }),
+            }, acceptsAny, p),
             deleteProperty: (target, prop) => {
                 if (!(0, IsSymbol_1.isSymbol)(prop))
                     validatePropertyValue(this, prop, void (0));

package/dist/esm/decorators/dto/Expect.js

@@ -3,7 +3,8 @@ import { setObjectPropertySchema } from '../../lib/dto/ObjectSchemaValidation.js
  * Declare the schema of a property of a DTO class. The DTO validates the property against it when it is constructed
  * (the whole object at once: defaults applied, the keys without schema removed unless the class has an
  * `@IndexSignature`), and each time the property, or a value nested in it, is changed afterwards (the change is undone
- * when invalid). The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
+ * when invalid). With `DTO.Any()`, an object of another class the property holds is given as it is, not watched: no
+ * change of it can be invalid. The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
  * actions' input validation. Subclasses inherit the property schemas, and may declare a property again to replace its
  * schema. Ignored on a symbol property or on a class which is not a DTO.
  * @param schema The schema of the property, built with the static methods of `DTO` (`DTO.String().required()`); a

package/dist/esm/exports/Core.js

@@ -61,4 +61,5 @@ export * from '../types/ModuleOptions.js';
  */
 export * from '../interfaces/IBaseObjectConstructor.js';
 export * from '../interfaces/ILogger.js';
+export * from '../interfaces/IInterfaceListening.js';
 export * from '../interfaces/IConstructor.js';

package/dist/esm/interfaces/IInterfaceListening.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/lib/base/internal/ConfigurableRecordsInjection.js

@@ -1,28 +1,24 @@
 import { DI_TARGET_ID } from '../../../constants/DIMetadataKey.js';
 import { constructorSymbol } from '../../ioc/ConstructorSymbol.js';
 import { As } from '@lakutata/utils/As';
+//The configurable records of the registrations, by resolver: each container keeps the options of its own registrations
+const registrationRecords = new WeakMap();
 /**
- * Set configurable records to target constructor with its registration name
- * @param target
- * @param registrationName
+ * Set configurable records to a registration (the options it was declared with)
+ * @param registration
  * @param configurableRecords
  * @constructor
  */
-export function setConfigurableRecords(target, registrationName, configurableRecords) {
-    if (Reflect.hasOwnMetadata(registrationName, target))
-        Reflect.deleteMetadata(registrationName, target);
-    Reflect.defineMetadata(registrationName, configurableRecords, target);
+export function setConfigurableRecords(registration, configurableRecords) {
+    registrationRecords.set(registration, configurableRecords);
 }
 /**
- * Get configurable records from target constructor by its registration name
- * @param target
+ * Get configurable records from a registration
+ * @param registration
  * @constructor
  */
-export function getConfigurableRecords(target, registrationName) {
-    const configurableRecords = Reflect.getOwnMetadata(registrationName, target);
-    if (configurableRecords)
-        return configurableRecords;
-    return {};
+export function getConfigurableRecords(registration) {
+    return (registration && registrationRecords.get(registration)) ?? {};
 }
 /**
  * Set id to instance

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

@@ -268,7 +268,8 @@ export class Container {
             throwWarning(`The configuration passed for the already created object "${As(resolved).className}" is ignored. Use a scoped or transient object to get an instance with its own configuration.`);
         }
         if (isNewSubBaseObject) {
-            const presetConfigurableRecords = getConfigurableRecords(As(resolved.constructor), registrationName);
+            //The options of the registration in effect here (a child container's registration shadows its parent's)
+            const presetConfigurableRecords = getConfigurableRecords(this.#dic.getRegistration(registrationName));
             //set id into object instance
             setIdToInstance(As(resolved), registrationName);
             //set configurable records into object instance
@@ -289,8 +290,8 @@ export class Container {
         const configurableRecords = { ...options, class: void (0) };
         delete configurableRecords.id;
         delete configurableRecords.class;
-        setConfigurableRecords(options.class, id, configurableRecords);
         pair[id] = this.#createResolver(options.class);
+        setConfigurableRecords(pair[id], configurableRecords);
         return pair;
     }
     /**

package/dist/esm/lib/dto/DTO.js

@@ -91,6 +91,55 @@ function getPropertySchema(instance, propertyKey) {
     schemas.set(propertyKey, schema);
     return schema;
 }
+/**
+ * Whether the properties of a DTO accept any value, per DTO class
+ */
+const anyValuePropertyCache = new WeakMap();
+/**
+ * Whether a schema accepts any value: an any schema without rule, value list, condition or external validation, so no
+ * change of a value it holds can fail validation
+ * @param schema
+ */
+function acceptsAnything(schema) {
+    if (!schema || schema.type !== 'any' || schema._rules.length || schema._valids || schema._invalids)
+        return false;
+    const terms = schema.$_terms;
+    return !['whens', 'externals'].some((term) => Array.isArray(terms[term]) && terms[term].length > 0);
+}
+/**
+ * Whether a property of a DTO accepts any value: declared with `DTO.Any()`, or undeclared and matched by an index
+ * signature `DTO.Any()` (the transport objects of a context)
+ * @param instance
+ * @param propertyKey
+ */
+function acceptsAnyValue(instance, propertyKey) {
+    if (typeof propertyKey !== 'string')
+        return false;
+    const properties = getCachedDTOSchema(anyValuePropertyCache, objectConstructor(instance), () => new Map());
+    let accepts = properties.get(propertyKey);
+    if (accepts !== undefined)
+        return accepts;
+    const objectSchema = As(getObjectSchema(instance));
+    const child = (objectSchema.$_terms.keys || []).find(({ key }) => key === propertyKey);
+    //An undeclared property: the first pattern matching its key (the index signature)
+    const pattern = child ? undefined : (objectSchema.$_terms.patterns || []).find((each) => each.regex
+        ? each.regex.test(propertyKey)
+        : !each.schema.validate(propertyKey).error);
+    accepts = acceptsAnything(child ? child.schema : pattern?.rule);
+    properties.set(propertyKey, accepts);
+    return accepts;
+}
+/**
+ * Whether an object is plain data: an array, an object literal, or an object without prototype (an instance of a
+ * subclass of Array or Object, and the objects of another realm, count as objects of other classes)
+ * @param value
+ */
+function isPlainData(value) {
+    const constructor = value.constructor;
+    if (constructor === Object || constructor === Array)
+        return true;
+    return constructor === undefined && Object.getPrototypeOf(value) === null;
+}
 /**
  * Validate property value (only the property when the properties are validated independently)
  * @param instance
@@ -157,8 +206,10 @@ function propertyState(target, prop) {
  * @param prop
  * @param receiver
  * @param validateFn
+ * @param acceptsAny Whether a property of the DTO holding the value accepts any value
+ * @param ownerKey The property of the DTO holding the value
  */
-function dynamicProxyProperty(target, prop, receiver, validateFn) {
+function dynamicProxyProperty(target, prop, receiver, validateFn, acceptsAny, ownerKey) {
     const propertyValue = Reflect.get(target, prop, receiver);
     if (!propertyValue)
         return propertyValue;
@@ -187,6 +238,11 @@ function dynamicProxyProperty(target, prop, receiver, validateFn) {
             apply: (method, _thisArg, args) => Reflect.apply(method, target, args)
         });
     }
+    //An object of another class held by a property accepting any value is given as it is: no change of it can be
+    //refused, and a proxy would break the getters reading its private fields, the internal slots of the built-ins (the
+    //size of a Map) and its identity
+    if (acceptsAny?.(ownerKey) && !isPlainData(propertyValue))
+        return propertyValue;
     return new Proxy(propertyValue, {
         set(target, p, value, receiver) {
             const state = propertyState(target, p);
@@ -201,7 +257,7 @@ function dynamicProxyProperty(target, prop, receiver, validateFn) {
             }
         },
         get(target, p, receiver) {
-            return dynamicProxyProperty(target, p, receiver, validateFn);
+            return dynamicProxyProperty(target, p, receiver, validateFn, acceptsAny, ownerKey);
         },
         deleteProperty: (target, prop) => {
             const state = propertyState(target, prop);
@@ -259,12 +315,22 @@ let DTO = DTO_1 = class DTO extends DataValidator {
      * Create a DTO from its data, validated against the class schema: the defaults applied, the keys without schema
      * removed (unless the class has an `@IndexSignature`). The instance then validates each change of a property, or
      * of a value nested in it (an array, an object): an invalid change throws an `InvalidValueException` and is
-     * undone.
+     * undone. A property accepting any value (`DTO.Any()`, or an index signature `DTO.Any()`) gives the objects of
+     * other classes it holds as they are, since no change of theirs can be invalid: their getters, their private fields
+     * and their identity are those of the object itself.
      * @param props The data of the DTO. Default: no data (`{}`).
      * @throws {InvalidValueException} When the data does not match the class schema.
      */
     constructor(props = {}) {
         super();
+        //Whether each property accepts any value, remembered by the instance once known
+        let accepting;
+        const acceptsAny = (key) => {
+            if (typeof key !== 'string')
+                return false;
+            accepting ??= Object.create(null);
+            return accepting[key] ??= acceptsAnyValue(this, key);
+        };
         //Create DTO proxy object
         const DTOInstanceProxy = new Proxy(this, {
             set: (target, prop, value, receiver) => {
@@ -280,7 +346,7 @@ let DTO = DTO_1 = class DTO extends DataValidator {
                 else {
                     validatePropertyValue(this, p, Reflect.get(target, p));
                 }
-            }),
+            }, acceptsAny, p),
             deleteProperty: (target, prop) => {
                 if (!isSymbol(prop))
                     validatePropertyValue(this, prop, void (0));

package/dist/types/decorators/dto/Expect.d.ts

@@ -5,7 +5,8 @@ import { Schema } from '../../lib/validation/types/Schema.js';
  * Declare the schema of a property of a DTO class. The DTO validates the property against it when it is constructed
  * (the whole object at once: defaults applied, the keys without schema removed unless the class has an
  * `@IndexSignature`), and each time the property, or a value nested in it, is changed afterwards (the change is undone
- * when invalid). The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
+ * when invalid). With `DTO.Any()`, an object of another class the property holds is given as it is, not watched: no
+ * change of it can be invalid. The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
  * actions' input validation. Subclasses inherit the property schemas, and may declare a property again to replace its
  * schema. Ignored on a symbol property or on a class which is not a DTO.
  * @param schema The schema of the property, built with the static methods of `DTO` (`DTO.String().required()`); a

package/dist/types/exports/Core.d.ts

@@ -90,4 +90,5 @@ export * from '../types/ModuleOptions.js';
  */
 export * from '../interfaces/IBaseObjectConstructor.js';
 export * from '../interfaces/ILogger.js';
+export * from '../interfaces/IInterfaceListening.js';
 export * from '../interfaces/IConstructor.js';

package/dist/types/interfaces/IInterfaceListening.d.ts

@@ -0,0 +1,159 @@
+import type { Server } from 'node:net';
+/**
+ * A network interface, as an implementation of {@link IInterfaceListening} takes it: its name (`'eth1'`; on Windows the
+ * name of the network connection), its hardware address (`{mac: '52:54:00:12:34:56'}`) or its index (`{index: 3}`).
+ */
+export type NetworkInterfaceSelector = string | {
+    /**
+     * The hardware address of the interface.
+     */
+    mac: string;
+} | {
+    /**
+     * The index of the interface.
+     */
+    index: number;
+};
+/**
+ * An address a listener of a network interface can be reached at.
+ */
+export interface IListeningAddress {
+    /**
+     * The address (an IPv6 address without its scope).
+     */
+    address: string;
+    /**
+     * `'IPv4'` or `'IPv6'`.
+     */
+    family: 'IPv4' | 'IPv6';
+    /**
+     * The port.
+     */
+    port: number;
+    /**
+     * IPv6 only: the scope of the address (the index of the interface for a link-local one), 0 for a global one.
+     */
+    scopeid?: number;
+}
+/**
+ * The options of {@link IInterfaceListening.listenOnAll}.
+ */
+export interface IInterfaceListenOptions {
+    /**
+     * The port; 0 lets the system choose one (for one interface only).
+     */
+    port: number;
+    /**
+     * The families listened on.
+     * @default 'both'
+     */
+    family?: 'IPv4' | 'IPv6' | 'both';
+    /**
+     * Refuse to listen where the connections reaching the addresses of the interface through another interface cannot
+     * be refused, and stop listening while they cannot. An implementation that never refuses them throws.
+     * @default false
+     */
+    strict?: boolean;
+}
+/**
+ * The listener of a network interface for a server: it accepts the connections of the interface and gives them to the
+ * server, whatever the addresses of the interface, again when they change and when the interface is unplugged and
+ * plugged back. The server itself does not listen. The `InterfaceListener` of `@lakutata/netif` implements it.
+ */
+export interface IInterfaceListener {
+    /**
+     * The interface listened on: its name (`undefined` while it does not exist), and whether it is the loopback one.
+     */
+    readonly networkInterface: {
+        readonly name: string | undefined;
+        readonly loopback: boolean;
+    };
+    /**
+     * The port, `undefined` until a port 0 is given one by the system.
+     */
+    readonly port: number | undefined;
+    /**
+     * The addresses it can be reached at now: none while the interface does not exist or has no address.
+     */
+    readonly addresses: IListeningAddress[];
+    /**
+     * Whether the interface is listened on now.
+     */
+    readonly listening: boolean;
+    /**
+     * Whether the system refuses the connections that reach the addresses of the interface through another interface.
+     */
+    readonly enforced: boolean;
+    /**
+     * Why `enforced` is `false`, when it is.
+     */
+    readonly reason: string | undefined;
+    /**
+     * Whether it was closed.
+     */
+    readonly closed: boolean;
+    /**
+     * Stop listening; the connections established are left to the server.
+     */
+    close(): Promise<void>;
+    /**
+     * The interface is listened on, again after a change.
+     * @param event `'listening'`.
+     * @param listener Called without argument.
+     */
+    on(event: 'listening', listener: () => void): this;
+    /**
+     * A failure of listening again, retried by the listener; with `strict`, the guarantee lost.
+     * @param event `'error'`.
+     * @param listener Called with the error.
+     */
+    on(event: 'error', listener: (error: Error) => void): this;
+    /**
+     * `enforced` changed.
+     * @param event `'enforced'`.
+     * @param listener Called with its new value.
+     */
+    on(event: 'enforced', listener: (enforced: boolean) => void): this;
+    /**
+     * The listener was closed.
+     * @param event `'close'`.
+     * @param listener Called without argument.
+     */
+    on(event: 'close', listener: () => void): this;
+    /**
+     * Remove a listener of an event.
+     * @param event The event.
+     * @param listener The listener given to `on()`.
+     */
+    off(event: 'listening' | 'error' | 'enforced' | 'close', listener: (...args: any[]) => void): this;
+}
+/**
+ * Listening on network interfaces instead of addresses: what the entrypoints use for their `interface` option. The
+ * package `@lakutata/netif` implements it, and is the one used by default; another implementation is given in the
+ * `interfaceListening` option of the entrypoints.
+ * @example
+ * ```typescript
+ * import type {IInterfaceListener, IInterfaceListening} from 'lakutata'
+ * import {listenOnAll} from '@lakutata/netif'
+ *
+ * //An implementation that writes each listener made before giving it to the entrypoint
+ * const logged: IInterfaceListening = {
+ *     listenOnAll: async (selectors, server, options): Promise<IInterfaceListener[]> => {
+ *         const listeners: IInterfaceListener[] = await listenOnAll(selectors, server, options)
+ *         for (const listener of listeners) console.log(listener.networkInterface.name, listener.addresses)
+ *         return listeners
+ *     }
+ * }
+ * ```
+ */
+export interface IInterfaceListening {
+    /**
+     * Listen on interfaces for a server, one listener by interface; when one cannot be listened on, the others are
+     * closed and the error is thrown. An interface that does not exist yet is listened on once it appears.
+     * @param selectors The interfaces; several need a port other than 0.
+     * @param server The server the connections are given to.
+     * @param options The port, the families, and whether the other interfaces must be refused.
+     * @returns The listeners, in the order of the interfaces.
+     */
+    listenOnAll(selectors: NetworkInterfaceSelector | NetworkInterfaceSelector[], server: Server, options: IInterfaceListenOptions): Promise<IInterfaceListener[]>;
+}

package/dist/types/lib/base/internal/ConfigurableRecordsInjection.d.ts

@@ -1,18 +1,18 @@
 import { BaseObject } from '../BaseObject.js';
+import { type Resolver } from '../../ioc/Resolvers.js';
 /**
- * Set configurable records to target constructor with its registration name
- * @param target
- * @param registrationName
+ * Set configurable records to a registration (the options it was declared with)
+ * @param registration
  * @param configurableRecords
  * @constructor
  */
-export declare function setConfigurableRecords<ClassConstructor extends typeof BaseObject>(target: ClassConstructor, registrationName: string | symbol, configurableRecords: Record<string, any>): void;
+export declare function setConfigurableRecords(registration: Resolver<any>, configurableRecords: Record<string, any>): void;
 /**
- * Get configurable records from target constructor by its registration name
- * @param target
+ * Get configurable records from a registration
+ * @param registration
  * @constructor
  */
-export declare function getConfigurableRecords<ClassConstructor extends typeof BaseObject>(target: ClassConstructor, registrationName: string | symbol): Record<string, any>;
+export declare function getConfigurableRecords(registration: Resolver<any> | null): Record<string, any>;
 /**
  * Set id to instance
  * @param target

package/dist/types/lib/dto/DTO.d.ts

@@ -45,7 +45,9 @@ export declare class DTO extends DataValidator {
      * Create a DTO from its data, validated against the class schema: the defaults applied, the keys without schema
      * removed (unless the class has an `@IndexSignature`). The instance then validates each change of a property, or
      * of a value nested in it (an array, an object): an invalid change throws an `InvalidValueException` and is
-     * undone.
+     * undone. A property accepting any value (`DTO.Any()`, or an index signature `DTO.Any()`) gives the objects of
+     * other classes it holds as they are, since no change of theirs can be invalid: their getters, their private fields
+     * and their identity are those of the object itself.
      * @param props The data of the DTO. Default: no data (`{}`).
      * @throws {InvalidValueException} When the data does not match the class schema.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/core",
-  "version": "3.1.0",
+  "version": "3.1.4",
   "description": "The core of the lakutata framework: the IoC container and dependency injection, the object model with asynchronous construction, and DTO schema validation with the API of joi.",
   "keywords": [
     "lakutata",
@@ -107,7 +107,7 @@
     "test:engine-types": "node scripts/check-engine-types.mjs"
   },
   "dependencies": {
-    "@lakutata/utils": "3.1.0",
+    "@lakutata/utils": "3.1.1",
     "reflect-metadata": "0.2.2"
   },
   "engines": {