@lakutata/core 3.0.0 → 3.1.1

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

@@ -2,7 +2,6 @@ import { format as utilFormat } from 'node:util';
 import { getAppId, getAppName } from './BasicInfo.js';
 import { templating } from '@lakutata/utils/Templating';
 import { As } from '@lakutata/utils/As';
-import { camelCase } from '@lakutata/utils/CamelCase';
 import { DevNull } from '@lakutata/utils/DevNull';
 /**
  * The placeholders of util.format() consuming an argument
@@ -83,7 +82,8 @@ export 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
@@ -120,9 +120,10 @@ export 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 = templating(template, templatingArgs, { ignoreMissing: true });
             }
@@ -143,11 +144,30 @@ export class Exception extends Error {
             }
         }
         else {
-            //Empty message
-            const message = 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;
+                As(this).errMsg = value;
+            }
+        });
+        this.errMsg = message;
         this.err = this.name;
     }
     /**

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

@@ -1,7 +1,8 @@
 import { DTO } from '../lib/dto/DTO.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'
@@ -21,12 +22,13 @@ import { DTO } from '../lib/dto/DTO.js';
  */
 export declare class PaginationSearchDTO extends DTO {
     /**
-     * The maximum number of items to return: an integer, 0 or more.
+     * The maximum number of items to return: an integer, 0 or more (its text too, as a query string gives it).
      * @default 10
      */
     limit?: number;
     /**
-     * The number of items to skip before the first one returned: an integer, 0 or more.
+     * The number of items to skip before the first one returned: an integer, 0 or more (its text too, as a query string
+     * gives it).
      * @default 0
      */
     offset?: number;

package/dist/types/exceptions/dto/InvalidValueException.d.ts

@@ -3,9 +3,11 @@ 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 declare class InvalidValueException extends Exception {
     errno: string | number;
+    readonly statusCode: number;
 }

package/dist/types/lib/app/Application.d.ts

@@ -1,4 +1,5 @@
 import { Module } from '../core/Module.js';
+import { __destroy } from '../base/BaseObject.js';
 import { ApplicationConfigLoader } from './ApplicationConfigLoader.js';
 import { ApplicationOptions } from '../../options/ApplicationOptions.js';
 import { Alias } from '../core/Alias.js';
@@ -270,6 +271,20 @@ export declare class Application extends Module {
      * @protected
      */
     protected static listenShutdownSignals(signals: NodeJS.Signals[]): void;
+    /**
+     * 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
+     */
+    protected static listenNaturalEnd(app: Application): void;
+    /**
+     * 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
+     */
+    protected static stopListeningNaturalEnd(): void;
     /**
      * 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.
@@ -328,6 +343,13 @@ export declare class Application extends Module {
      * variable.
      */
     get timezone(): string;
+    /**
+     * 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
+     */
+    protected [__destroy](...hooks: (() => Promise<void>)[]): Promise<void>;
     /**
      * The time the process has been running, in seconds (rounded down).
      */

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/dist/types/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/package.json

@@ -1,7 +1,31 @@
 {
   "name": "@lakutata/core",
-  "version": "3.0.0",
-  "description": "Core of the lakutata IoC framework (IoC/DI, BaseObject, DTO/validation, decorators, console logger, monitor).",
+  "version": "3.1.1",
+  "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",
+    "ioc",
+    "dependency-injection",
+    "di",
+    "container",
+    "decorators",
+    "dto",
+    "validation",
+    "joi",
+    "typescript"
+  ],
+  "homepage": "https://lakutata.com/packages/core",
+  "bugs": {
+    "url": "https://github.com/lakutata/lakutata/issues",
+    "email": "admin@lakutata.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lakutata/lakutata.git",
+    "directory": "packages/core"
+  },
+  "author": "alex.ma",
+  "license": "MIT",
   "type": "module",
   "main": "./dist/cjs/exports/Core.js",
   "types": "./dist/cjs/exports/Core.d.ts",
@@ -83,11 +107,11 @@
     "test:engine-types": "node scripts/check-engine-types.mjs"
   },
   "dependencies": {
-    "@lakutata/utils": "3.0.0",
+    "@lakutata/utils": "3.1.1",
     "reflect-metadata": "0.2.2"
   },
   "engines": {
-    "node": ">=22"
+    "node": "^22.13.0 || >=24.11.0"
   },
   "files": [
     "dist",