@lakutata/core 3.0.0 → 3.1.1

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;
@@ -183,8 +234,18 @@ function dynamicProxyProperty(target, prop, receiver, validateFn) {
                 }
             };
         }
-        return propertyValue.bind(target);
+        //A method is called on its object, not on the proxy (the internal slots of a Date, a Map); the function itself is
+        //kept, with its own properties: an express application is a function whose methods (its own bind among them)
+        //its requests read
+        return new Proxy(propertyValue, {
+            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);
@@ -199,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);
@@ -257,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) => {
@@ -278,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/cjs/lib/foundation/Exception.d.ts

@@ -30,7 +30,8 @@ export declare function exceptionParams(exception: Error): Record<string, unknow
  *   leaves its placeholder in the message; building the message never throws.
  * - `new XxxException('Order not found')`: the message as given.
  * - `new XxxException(error)`: the message of another error.
- * - `new XxxException()`: a message made from the class name.
+ * - `new XxxException()`: a message made from the words of the class name, the acronyms kept (`Order not found
+ *   exception` for `OrderNotFoundException`, `HTTP request exception` for `HTTPRequestException`).
  *
  * The template parameters are kept for the translation of the message, see {@link exceptionParams}.
  * @example

package/dist/cjs/lib/foundation/Exception.js

@@ -6,7 +6,6 @@ const node_util_1 = require("node:util");
 const BasicInfo_js_1 = require("./BasicInfo.js");
 const Templating_1 = require("@lakutata/utils/Templating");
 const As_1 = require("@lakutata/utils/As");
-const CamelCase_1 = require("@lakutata/utils/CamelCase");
 const DevNull_1 = require("@lakutata/utils/DevNull");
 /**
  * The placeholders of util.format() consuming an argument
@@ -87,7 +86,8 @@ function exceptionParams(exception) {
  *   leaves its placeholder in the message; building the message never throws.
  * - `new XxxException('Order not found')`: the message as given.
  * - `new XxxException(error)`: the message of another error.
- * - `new XxxException()`: a message made from the class name.
+ * - `new XxxException()`: a message made from the words of the class name, the acronyms kept (`Order not found
+ *   exception` for `OrderNotFoundException`, `HTTP request exception` for `HTTPRequestException`).
  *
  * The template parameters are kept for the translation of the message, see {@link exceptionParams}.
  * @example
@@ -124,9 +124,10 @@ class Exception extends Error {
         this.statusCode = 500;
         if (b.length) {
             const template = a;
-            const templatingArgs = b.length > 1 ? b : b[0];
+            //The parameters given one by one ({0}, {1}…), even a single one, or the object or array given alone
+            const templatingArgs = b.length > 1 || typeof b[0] !== 'object' || b[0] === null ? b : b[0];
             //Kept for the translations of the message, not an enumerable property (the errors sent are not changed)
-            Object.defineProperty(this, PARAMS, { value: b.length > 1 || typeof b[0] !== 'object' || b[0] === null ? b : b[0], enumerable: false });
+            Object.defineProperty(this, PARAMS, { value: templatingArgs, enumerable: false });
             try {
                 this.message = (0, Templating_1.templating)(template, templatingArgs, { ignoreMissing: true });
             }
@@ -147,11 +148,30 @@ class Exception extends Error {
             }
         }
         else {
-            //Empty message
-            const message = (0, CamelCase_1.camelCase)(this.name).toLowerCase();
+            //Empty message: the words of the class name, in lower case but the acronyms
+            const message = this.name
+                .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+                .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+                .split(/[\s_-]+/)
+                .filter((word) => !!word)
+                .map((word) => /^[A-Z\d]{2,}$/.test(word) ? word : word.toLowerCase())
+                .join(' ');
             this.message = `${message.charAt(0).toUpperCase()}${message.slice(1)}`;
         }
-        this.errMsg = this.message;
+        //message as an accessor writing errMsg too (enumerable as the message assigned before): a subclass setting its
+        //message in a field initializer (run after this constructor) keeps errMsg the same, errMsg staying a data
+        //property (serialized, logged as it is)
+        let message = this.message;
+        Object.defineProperty(this, 'message', {
+            configurable: true,
+            enumerable: true,
+            get: () => message,
+            set: (value) => {
+                message = value;
+                (0, As_1.As)(this).errMsg = value;
+            }
+        });
+        this.errMsg = message;
         this.err = this.name;
     }
     /**

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/dto/PaginationSearchDTO.js

@@ -10,8 +10,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { DTO } from '../lib/dto/DTO.js';
 import { Expect } from '../decorators/dto/Expect.js';
 /**
- * The input of a paginated search: how many items to return and how many to skip. Extend it with the search criteria,
- * and pass the validated input to `paginator()`.
+ * The input of a paginated search: how many items to return and how many to skip, numbers or their text (the query
+ * string of a request, `?limit=20&offset=40`). Extend it with the search criteria, and pass the validated input to
+ * `paginator()`.
  * @example
  * ```typescript
  * import {DTO} from 'lakutata'
@@ -32,10 +33,10 @@ import { Expect } from '../decorators/dto/Expect.js';
 export class PaginationSearchDTO extends DTO {
 }
 __decorate([
-    Expect(DTO.Number().integer().positive().allow(0).optional().default(10)),
+    Expect(DTO.Number().integer().positive().allow(0).strict(false).optional().default(10)),
     __metadata("design:type", Number)
 ], PaginationSearchDTO.prototype, "limit", void 0);
 __decorate([
-    Expect(DTO.Number().integer().positive().allow(0).optional().default(0)),
+    Expect(DTO.Number().integer().positive().allow(0).strict(false).optional().default(0)),
     __metadata("design:type", Number)
 ], PaginationSearchDTO.prototype, "offset", void 0);

package/dist/esm/exceptions/dto/InvalidValueException.js

@@ -3,12 +3,14 @@ import { Exception } from '../../lib/foundation/Exception.js';
  * Thrown when a value does not match its schema: by `DTO.validate()` and `DTO.validateAsync()`, by the DTO constructor
  * and the assignments to a DTO property, and by the creation of an object whose `@Configurable` value is invalid. Its
  * message describes the first error; its causes lead to the `SchemaValidationException` holding the details (the path
- * and the rule of each error). Its `errno` is `E_INVALID_VALUE`; the HTTP entrypoints answer an invalid action input with the
- * status 400, JSON-RPC with the error "invalid params".
+ * and the rule of each error). Its `errno` is `E_INVALID_VALUE` and its `statusCode` 400, a value refused being an
+ * error of the caller: the HTTP entrypoints answer an invalid action input with the status 400, the service transports
+ * send the error with it, JSON-RPC answers with the error "invalid params".
  */
 export class InvalidValueException extends Exception {
     constructor() {
         super(...arguments);
         this.errno = 'E_INVALID_VALUE';
+        this.statusCode = 400;
     }
 }

package/dist/esm/lib/app/Application.js

@@ -8,6 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Module } from '../core/Module.js';
+import { __destroy } from '../base/BaseObject.js';
 import { Container } from '../core/Container.js';
 import { ApplicationConfigLoader } from './ApplicationConfigLoader.js';
 import { ApplicationOptions } from '../../options/ApplicationOptions.js';
@@ -130,6 +131,16 @@ export class Application extends Module {
      * @private
      */
     static #consoleLogger;
+    /**
+     * Whether the application is exiting: a step of its bootstrap that exits it (a command of the migrations) ends its
+     * launch
+     */
+    static #exiting = false;
+    /**
+     * The listener of the end of the process once nothing keeps it busy (beforeExit): the launched application exits
+     * gracefully then, as with exit()
+     */
+    static #naturalEnd;
     /**
      * Preset the options of the applications, before they run: the packages assembling the framework preset their
      * components (the `lakutata` package presets its Logger as `log` and its Entrypoint as `entrypoint`). An object
@@ -368,6 +379,36 @@ export class Application extends Module {
             });
         }
     }
+    /**
+     * End the launched application gracefully once nothing keeps the process busy (no server, connection or timer
+     * left): its exit, with the exit code the process has (`process.exitCode`, 0 by default), as with `exit()`. A
+     * process ending so does not wait for an exit, so the done handlers and the teardown would not run otherwise.
+     * @param app The launched application.
+     * @protected
+     */
+    static listenNaturalEnd(app) {
+        Application.stopListeningNaturalEnd();
+        const listener = () => {
+            Application.stopListeningNaturalEnd();
+            //Exiting already (a signal, exit()): its teardown runs
+            if (Application.#exiting)
+                return;
+            const code = Number(process.exitCode ?? 0);
+            Application.eventEmitter.emit('exit', app, Number.isInteger(code) ? code : 1);
+        };
+        Application.#naturalEnd = listener;
+        process.once('beforeExit', listener);
+    }
+    /**
+     * Stop ending the application with the process: it exits, or it is destroyed (disposed by a test, which leaves the
+     * end of the process to its runner)
+     * @protected
+     */
+    static stopListeningNaturalEnd() {
+        if (Application.#naturalEnd)
+            process.removeListener('beforeExit', Application.#naturalEnd);
+        Application.#naturalEnd = undefined;
+    }
     /**
      * Launch the application: environment variables, aliases, options (or the database migration command given by the
      * `MIGRATION_*` environment variables), then the application created in a new root container.
@@ -376,6 +417,7 @@ export class Application extends Module {
      */
     static async launchApplication() {
         this.eventEmitter.once('exit', async (app, exitCode, signal) => {
+            this.#exiting = true;
             try {
                 //The done handler, told why the application exits
                 const reason = signal ? { code: exitCode ? exitCode : 0, signal: signal } : { code: exitCode ? exitCode : 0 };
@@ -491,6 +533,9 @@ export class Application extends Module {
                 if (applicationOptions.shutdownSignals)
                     this.listenShutdownSignals(applicationOptions.shutdownSignals);
                 applicationOptions.bootstrap?.push(async (target) => {
+                    //Exited by a step of the bootstrap: its container is being destroyed, it does not launch
+                    if (Application.#exiting)
+                        return;
                     const launchedCallbackRemover = function () {
                         this.options.bootstrap?.pop();
                         As(Reflect.getOwnMetadata('#bootstrap', this))?.pop();
@@ -502,6 +547,7 @@ export class Application extends Module {
                     markApplicationLaunched(target);
                     //The application launched is the one the signals end (its launched handlers may receive them)
                     Reflect.set(this, 'appInstance', target);
+                    Application.listenNaturalEnd(As(target));
                     this.eventEmitter.emit(ApplicationState.Launched, As(target));
                 });
                 //Resolved once the application is initialized (its objects loaded, its bootstrap run), rejected with
@@ -576,6 +622,16 @@ export class Application extends Module {
     get timezone() {
         return getBasicInfo().timezone;
     }
+    /**
+     * The framework's destroyer, see {@link Module}: a destroyed application no longer ends with the process.
+     * @param hooks The steps the framework's subclasses run before `destroy()`.
+     * @returns Resolves once the application and its objects are destroyed.
+     * @protected
+     */
+    async [__destroy](...hooks) {
+        Application.stopListeningNaturalEnd();
+        return await super[__destroy](...hooks);
+    }
     /**
      * The time the process has been running, in seconds (rounded down).
      */

package/dist/esm/lib/base/BaseObject.js

@@ -556,7 +556,9 @@ let BaseObject = BaseObject_1 = class BaseObject extends AsyncConstructor {
      */
     getMethod(name, throwExceptionIfNotFound = false) {
         if (this.hasMethod(name)) {
-            return (...args) => this[name](...args);
+            //Named: else V8 names it after the code below in the stack traces (MethodNotFoundException.methodName)
+            const callMethod = (...args) => this[name](...args);
+            return callMethod;
         }
         else if (throwExceptionIfNotFound) {
             throw new MethodNotFoundException('Method "{methodName}" not found in "{className}"', {

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;
@@ -180,8 +231,18 @@ function dynamicProxyProperty(target, prop, receiver, validateFn) {
                 }
             };
         }
-        return propertyValue.bind(target);
+        //A method is called on its object, not on the proxy (the internal slots of a Date, a Map); the function itself is
+        //kept, with its own properties: an express application is a function whose methods (its own bind among them)
+        //its requests read
+        return new Proxy(propertyValue, {
+            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);
@@ -196,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);
@@ -254,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) => {
@@ -275,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));