@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/esm/options/LoadAnonymousObjectOptions.js

@@ -0,0 +1,48 @@
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '../lib/dto/DTO.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+import { Expect } from '../decorators/dto/Expect.js';
+import { IndexSignature } from '../decorators/dto/IndexSignature.js';
+/**
+ * The declaration of an anonymous object in the `objects.anonymous` module option: its class and its options. The
+ * object is registered by its class (got with `getObject(TheClass)` or `@Inject(TheClass)`), with its options; the
+ * keys other than `class` are its options (the values of its `@Configurable` properties).
+ * @example
+ * ```typescript
+ * import {Application, BaseObject, DTO, type LoadAnonymousObjectOptions} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Mailer extends BaseObject {
+ *     @Configurable(DTO.String())
+ *     protected readonly host: string = 'localhost'
+ * }
+ *
+ * const mailer: LoadAnonymousObjectOptions = {class: Mailer, host: 'smtp.example.com'}
+ *
+ * Application.run({
+ *     id: 'mail.app',
+ *     name: 'Mail',
+ *     objects: {
+ *         anonymous: [mailer]
+ *     }
+ * })
+ * ```
+ */
+let LoadAnonymousObjectOptions = class LoadAnonymousObjectOptions extends DTO {
+};
+__decorate([
+    Expect(DTO.Class(() => BaseObject).required()),
+    __metadata("design:type", Object)
+], LoadAnonymousObjectOptions.prototype, "class", void 0);
+LoadAnonymousObjectOptions = __decorate([
+    IndexSignature(DTO.Any())
+], LoadAnonymousObjectOptions);
+export { LoadAnonymousObjectOptions };

package/dist/esm/options/LoadNamedObjectOptions.js

@@ -0,0 +1,39 @@
+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;
+};
+import { DTO } from '../lib/dto/DTO.js';
+import { LoadObjectOptions } from './LoadObjectOptions.js';
+import { IndexSignature } from '../decorators/dto/IndexSignature.js';
+/**
+ * The named objects of the `objects.named` module option: each declaration (its class and its options, see
+ * {@link LoadObjectOptions}) under the name the object is registered under (got with `getObject('name')` or
+ * `@Inject('name')`). A module is declared here.
+ * @example
+ * ```typescript
+ * import {Application, BaseObject, type LoadNamedObjectOptions} from 'lakutata'
+ *
+ * class Cart extends BaseObject {
+ * }
+ *
+ * const named: LoadNamedObjectOptions = {
+ *     cart: {class: Cart}
+ * }
+ *
+ * Application.run({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     objects: {
+ *         named: named
+ *     }
+ * })
+ * ```
+ */
+let LoadNamedObjectOptions = class LoadNamedObjectOptions extends DTO {
+};
+LoadNamedObjectOptions = __decorate([
+    IndexSignature(LoadObjectOptions.Schema())
+], LoadNamedObjectOptions);
+export { LoadNamedObjectOptions };

package/dist/esm/options/LoadObjectOptions.js

@@ -0,0 +1,50 @@
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+import { DTO } from '../lib/dto/DTO.js';
+import { Expect } from '../decorators/dto/Expect.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+import { IndexSignature } from '../decorators/dto/IndexSignature.js';
+export const OBJECT_ID = Symbol('OBJECT_ID');
+/**
+ * The declaration of an object given to `Container.load()` and in the `objects.named` module option: its class and its
+ * options (the keys other than `class`, the values of its `@Configurable` properties).
+ * @example
+ * ```typescript
+ * import {BaseObject, Container, DTO, type LoadObjectOptions} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Mailer extends BaseObject {
+ *     @Configurable(DTO.String())
+ *     protected readonly host: string = 'localhost'
+ * }
+ *
+ * const declaration: LoadObjectOptions = {class: Mailer, host: 'smtp.example.com'}
+ *
+ * const container: Container = new Container()
+ * await container.load([declaration])
+ * const mailer: Mailer = await container.get(Mailer)
+ * ```
+ */
+let LoadObjectOptions = class LoadObjectOptions extends DTO {
+    static { _a = OBJECT_ID; }
+};
+__decorate([
+    Expect(DTO.Alternatives(DTO.String(), DTO.Symbol()).optional()),
+    __metadata("design:type", Object)
+], LoadObjectOptions.prototype, _a, void 0);
+__decorate([
+    Expect(DTO.Class(() => BaseObject).required()),
+    __metadata("design:type", Object)
+], LoadObjectOptions.prototype, "class", void 0);
+LoadObjectOptions = __decorate([
+    IndexSignature(DTO.Any())
+], LoadObjectOptions);
+export { LoadObjectOptions };

package/dist/esm/options/ModuleLoadObjectsOptions.js

@@ -0,0 +1,57 @@
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '../lib/dto/DTO.js';
+import { Expect } from '../decorators/dto/Expect.js';
+import { LoadNamedObjectOptions } from './LoadNamedObjectOptions.js';
+import { LoadAnonymousObjectOptions } from './LoadAnonymousObjectOptions.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+/**
+ * The `objects` module option: the objects a module declares besides its components and providers (plain objects,
+ * modules), named or anonymous.
+ * @example
+ * ```typescript
+ * import {Application, BaseObject, type ModuleLoadObjectsOptions, Module} from 'lakutata'
+ *
+ * class Cart extends BaseObject {
+ * }
+ *
+ * class Catalog extends Module {
+ * }
+ *
+ * const objects: ModuleLoadObjectsOptions = {
+ *     named: {
+ *         catalog: {class: Catalog}
+ *     },
+ *     anonymous: [Cart, './dist/objects/*.js']
+ * }
+ *
+ * Application.run({id: 'shop.app', name: 'Shop', objects: objects})
+ * ```
+ */
+export class ModuleLoadObjectsOptions extends DTO {
+}
+__decorate([
+    Expect(LoadNamedObjectOptions.optional().default({})),
+    __metadata("design:type", LoadNamedObjectOptions
+    /**
+     * The objects registered by their class (got with `getObject(TheClass)` or `@Inject(TheClass)`): classes,
+     * declarations (`{class, ...options}`), or glob patterns of the files to import, relative to the working
+     * directory, each file registering every export which is a {@link BaseObject} subclass (a file failing to import
+     * fails the module's initialization).
+     * @default []
+     */
+    )
+], ModuleLoadObjectsOptions.prototype, "named", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Alternatives(LoadAnonymousObjectOptions.Schema(), DTO.Class(BaseObject), DTO.Glob()))
+        .optional()
+        .default([])),
+    __metadata("design:type", Array)
+], ModuleLoadObjectsOptions.prototype, "anonymous", void 0);

package/dist/esm/options/ModuleOptions.js

@@ -0,0 +1,82 @@
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '../lib/dto/DTO.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+import { Expect } from '../decorators/dto/Expect.js';
+import { ModuleLoadObjectsOptions } from './ModuleLoadObjectsOptions.js';
+import { OverridableNamedObjectOptions } from './OverridableNamedObjectOptions.js';
+/**
+ * The options of a module (and the base of the application options): the components, providers and objects it
+ * declares, and its bootstrap steps. A module gives its own by the initializer of its `options` property; the options
+ * configured for it are merged over them.
+ * @example
+ * ```typescript
+ * import {Component, Module, type ModuleOptions, Provider} from 'lakutata'
+ *
+ * class Inventory extends Component {
+ * }
+ *
+ * class StockQuery extends Provider {
+ * }
+ *
+ * export class StockModule extends Module {
+ *     protected options: ModuleOptions = {
+ *         components: {
+ *             inventory: {class: Inventory, maxListeners: 50}
+ *         },
+ *         providers: {
+ *             stock: {class: StockQuery}
+ *         },
+ *         bootstrap: [
+ *             'inventory',
+ *             async (module: Module): Promise<void> => {
+ *                 await module.getObject('stock')
+ *             }
+ *         ]
+ *     }
+ * }
+ * ```
+ */
+export class ModuleOptions extends DTO {
+}
+__decorate([
+    Expect(OverridableNamedObjectOptions.optional()),
+    __metadata("design:type", OverridableNamedObjectOptions)
+], ModuleOptions.prototype, "components", void 0);
+__decorate([
+    Expect(OverridableNamedObjectOptions.optional()),
+    __metadata("design:type", OverridableNamedObjectOptions)
+], ModuleOptions.prototype, "providers", void 0);
+__decorate([
+    Expect(ModuleLoadObjectsOptions
+        .optional()
+        .default({
+        named: {},
+        anonymous: []
+    })),
+    __metadata("design:type", ModuleLoadObjectsOptions
+    /**
+     * The steps run in order once the module's objects are registered: a name, a symbol or a class is got from the
+     * module (creating the object, such as a server starting to listen), an async function is called with the module.
+     * A failing step fails the module's initialization (for the application, a fatal exception).
+     * @default []
+     */
+    )
+], ModuleOptions.prototype, "objects", void 0);
+__decorate([
+    Expect(DTO.Array(DTO.Alternatives(DTO.String(), DTO.Class(BaseObject), DTO.AsyncFunction()))
+        .optional()
+        .default([])),
+    __metadata("design:type", Array)
+], ModuleOptions.prototype, "bootstrap", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional()),
+    __metadata("design:type", Boolean)
+], ModuleOptions.prototype, "checkOptions", void 0);

package/dist/esm/options/OverridableNamedObjectOptions.js

@@ -0,0 +1,34 @@
+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;
+};
+import { DTO } from '../lib/dto/DTO.js';
+import { OverridableObjectOptions } from './OverridableObjectOptions.js';
+import { IndexSignature } from '../decorators/dto/IndexSignature.js';
+/**
+ * The `components` and `providers` module options: each declaration (see {@link OverridableObjectOptions}) under the
+ * name the object is registered under (got with `getObject('name')` or `@Inject('name')`).
+ * @example
+ * ```typescript
+ * import {Application, Component, type IBaseObjectConstructor, type OverridableNamedObjectOptions} from 'lakutata'
+ *
+ * class Mailer extends Component {
+ * }
+ *
+ * const components: OverridableNamedObjectOptions<IBaseObjectConstructor<Component>> = {
+ *     mailer: {class: Mailer},
+ *     //Completes the options of the "log" component preset by the lakutata package
+ *     log: {level: 'debug'}
+ * }
+ *
+ * Application.run({id: 'mail.app', name: 'Mail', components: components})
+ * ```
+ */
+let OverridableNamedObjectOptions = class OverridableNamedObjectOptions extends DTO {
+};
+OverridableNamedObjectOptions = __decorate([
+    IndexSignature(OverridableObjectOptions.Schema())
+], OverridableNamedObjectOptions);
+export { OverridableNamedObjectOptions };

package/dist/esm/options/OverridableObjectOptions.js

@@ -0,0 +1,49 @@
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from '../lib/dto/DTO.js';
+import { BaseObject } from '../lib/base/BaseObject.js';
+import { Expect } from '../decorators/dto/Expect.js';
+import { IndexSignature } from '../decorators/dto/IndexSignature.js';
+/**
+ * The declaration of a component or a provider in the module options: its class and its options (the keys other than
+ * `class`, the values of its `@Configurable` properties). Without class, it completes the options of the object of the
+ * same name declared by the module's initializer or by `Application.preset()`: its options override theirs.
+ * @example
+ * ```typescript
+ * import {Component, DTO, Module, type ModuleOptions, type OverridableObjectOptions} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Cache extends Component {
+ *     @Configurable(DTO.Number().integer().min(0))
+ *     protected readonly ttl: number = 60
+ * }
+ *
+ * const declaration: OverridableObjectOptions<typeof Cache> = {class: Cache, ttl: 300}
+ *
+ * export class CacheModule extends Module {
+ *     protected options: ModuleOptions = {
+ *         components: {cache: declaration}
+ *     }
+ * }
+ *
+ * //The cache of this module keeps its entries 10 seconds: its ttl overrides the declared one
+ * export const override: OverridableObjectOptions<typeof Cache> = {ttl: 10}
+ * ```
+ */
+let OverridableObjectOptions = class OverridableObjectOptions extends DTO {
+};
+__decorate([
+    Expect(DTO.Class(() => BaseObject).optional()),
+    __metadata("design:type", Object)
+], OverridableObjectOptions.prototype, "class", void 0);
+OverridableObjectOptions = __decorate([
+    IndexSignature(DTO.Any())
+], OverridableObjectOptions);
+export { OverridableObjectOptions };

package/dist/esm/types/ActionPattern.js

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

package/dist/esm/types/ApplicationExitReason.js

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

package/dist/esm/types/ClassDecorator.js

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

package/dist/esm/types/ComponentOptions.js

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

package/dist/esm/types/CronOptions.js

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

package/dist/esm/types/JSONSchema.js

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

package/dist/esm/types/MethodDecorator.js

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

package/dist/esm/types/ModuleOptions.js

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

package/dist/esm/types/ObjectOptions.js

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

package/dist/esm/types/PaginationMeta.js

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

package/dist/esm/types/ParameterDecorator.js

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

package/dist/esm/types/PropertyDecorator.js

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

package/dist/esm/types/ProviderOptions.js

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

package/dist/types/components/ConsoleLogger.d.ts

@@ -0,0 +1,62 @@
+import { Component } from '../lib/core/Component.js';
+import { ILogger } from '../interfaces/ILogger.js';
+/**
+ * The logger of a core-only application, writing plain lines to the console:
+ * `[<ISO time>] <LEVEL> (<application name>): <message>`, formatted as `util.format()` (an object given before its
+ * message is written after it); the warnings and errors to stderr, the other levels to stdout. The application uses it
+ * when it has no `log` component; register it as `log` to configure its level. The `lakutata` package replaces it with
+ * its Logger component.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {ConsoleLogger} from '@lakutata/core/com/logger'
+ *
+ * Application.run({
+ *     id: 'tool.app',
+ *     name: 'Tool',
+ *     components: {
+ *         log: {class: ConsoleLogger, level: 'debug'}
+ *     }
+ * }).onLaunched((app, logger): void => logger.debug({pid: process.pid}, 'Launched'))
+ * ```
+ */
+export declare class ConsoleLogger extends Component implements ILogger {
+    /**
+     * The lowest level written: `trace`, `debug`, `info`, `warn`, `error`, or `silent` for none.
+     * @default 'info'
+     * @protected
+     */
+    protected readonly level: string;
+    /**
+     * Write a log line, unless its level is below the configured one.
+     * @param level The level of the line (`trace`, `debug`, `info`, `warn`, `error`).
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     * @protected
+     */
+    protected write(level: string, args: unknown[]): void;
+    /**
+     * Log an error to stderr.
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    error(...args: any[]): void;
+    /**
+     * Log a warning to stderr.
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    warn(...args: any[]): void;
+    /**
+     * Log an information to stdout.
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    info(...args: any[]): void;
+    /**
+     * Log a debugging detail to stdout (written when the level is `debug` or `trace`).
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    debug(...args: any[]): void;
+    /**
+     * Log a tracing detail to stdout (written when the level is `trace`).
+     * @param args An object (or error) and its message, or a message and its format arguments.
+     */
+    trace(...args: any[]): void;
+}

package/dist/types/constants/DIMetadataKey.d.ts

@@ -0,0 +1,10 @@
+import 'reflect-metadata';
+export declare const DI_CONTAINER_INJECT_PROPERTIES: symbol;
+export declare const DI_TARGET_CONSTRUCTOR_LIFETIME: symbol;
+export declare const DI_TARGET_CONSTRUCTOR_LIFETIME_LOCK: symbol;
+export declare const DI_TARGET_CONSTRUCTOR_INJECTS: symbol;
+export declare const DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES: symbol;
+export declare const DI_TARGET_CONSTRUCTOR_SYMBOL: symbol;
+export declare const DI_TARGET_CONSTRUCTOR_AUTOLOAD: symbol;
+export declare const DI_TARGET_CONTAINER: symbol;
+export declare const DI_TARGET_ID: symbol;

package/dist/types/constants/DTOMetadataKey.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export declare const DTO_CONSTRUCTOR: symbol;
+export declare const DTO_INDEX_SIGNATURE_SCHEMA: symbol;
+export declare const DTO_PROPERTY_SCHEMAS: symbol;
+export declare const DTO_OBJECT_REFINEMENT: symbol;

package/dist/types/decorators/asst/After.d.ts

@@ -0,0 +1,29 @@
+import { MethodDecorator } from '../../types/MethodDecorator.js';
+import { AfterFunction } from '../../lib/base/internal/MethodAssistantFunction.js';
+/**
+ * Run a function after each call of the decorated method, with its result. The function is called with the instance as
+ * `this`; a value it returns other than `undefined` replaces the result, `undefined` keeps it. Several `@After` on a
+ * method run in turn, each one receiving the result left by the previous one; an error thrown by the function is thrown
+ * by the call.
+ * @param afterFunc The function receiving the method's result (awaited when the method is async), and returning a
+ * value of the method's return type (a promise for an async method). It may be async only when the method is async.
+ * @returns The method decorator.
+ * @throws {InvalidAssistantFunctionTypeException} When the class is defined, if `afterFunc` is async and the method is
+ * not, or if the decorated member is not a method.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {After} from 'lakutata/decorator/asst'
+ *
+ * class Prices extends Component {
+ *     //The prices are rounded to cents, whatever their computation
+ *     @After(async function (this: Prices, price: number): Promise<number> {
+ *         return Math.round(price * 100) / 100
+ *     })
+ *     public async withTax(price: number): Promise<number> {
+ *         return price * 1.196
+ *     }
+ * }
+ * ```
+ */
+export declare function After<ClassPrototype extends Object, Method extends (...args: any[]) => unknown>(afterFunc: AfterFunction<ClassPrototype, Method>): MethodDecorator<ClassPrototype, Method>;

package/dist/types/decorators/asst/Before.d.ts

@@ -0,0 +1,28 @@
+import { MethodDecorator } from '../../types/MethodDecorator.js';
+import { BeforeFunction } from '../../lib/base/internal/MethodAssistantFunction.js';
+/**
+ * Run a function before each call of the decorated method, with its arguments. The function is called with the
+ * instance as `this`; an array it returns replaces the arguments passed to the method, `undefined` keeps them. Several
+ * `@Before` on a method run in turn, each one receiving the arguments left by the previous one; an error thrown by the
+ * function is thrown by the call, and the method does not run.
+ * @param beforeFunc The function receiving the method's arguments. It may be async only when the method is async.
+ * @returns The method decorator.
+ * @throws {InvalidAssistantFunctionTypeException} When the class is defined, if `beforeFunc` is async and the method is
+ * not, or if the decorated member is not a method.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {Before} from 'lakutata/decorator/asst'
+ *
+ * class Users extends Component {
+ *     //The names are looked up trimmed and in lower case
+ *     @Before(function (this: Users, name: string): [string] {
+ *         return [name.trim().toLowerCase()]
+ *     })
+ *     public async find(name: string): Promise<string | undefined> {
+ *         return name === 'ada' ? 'Ada Lovelace' : undefined
+ *     }
+ * }
+ * ```
+ */
+export declare function Before<ClassPrototype extends Object, Method extends (...args: any[]) => unknown>(beforeFunc: BeforeFunction<ClassPrototype, Method>): MethodDecorator<ClassPrototype, Method>;

package/dist/types/decorators/di/Autoload.d.ts

@@ -0,0 +1,33 @@
+import { BaseObject } from '../../lib/base/BaseObject.js';
+import { ClassDecorator } from '../../types/ClassDecorator.js';
+/**
+ * Let the container register the class on first use: when the class is requested (by `getObject(TheClass)` or
+ * `@Inject(TheClass)`) and is not registered, it is registered, then resolved, instead of failing. A singleton is
+ * registered in the root container (shared by the whole application), a scoped class in the nearest scope (shared
+ * within the request), a transient class in the requesting container. The registration has no options: the
+ * `@Configurable` properties take the options given to `getObject()`, else their initializers or their schema
+ * defaults. The mark is not inherited by subclasses.
+ * @returns The class decorator.
+ * @example
+ * ```typescript
+ * import {Component, Provider} from 'lakutata'
+ * import {Autoload, Inject, Scoped} from 'lakutata/decorator/di'
+ *
+ * //Not declared in the application: registered the first time it is injected
+ * @Autoload()
+ * @Scoped()
+ * class RequestClock extends Provider {
+ *     public readonly startedAt: number = Date.now()
+ * }
+ *
+ * class Reports extends Component {
+ *     @Inject(RequestClock)
+ *     protected readonly clock!: RequestClock
+ *
+ *     public elapsed(): number {
+ *         return Date.now() - this.clock.startedAt
+ *     }
+ * }
+ * ```
+ */
+export declare function Autoload<ClassConstructor extends typeof BaseObject>(): ClassDecorator<ClassConstructor>;

package/dist/types/decorators/di/Configurable.d.ts

@@ -0,0 +1,51 @@
+import { PropertyDecorator } from '../../types/PropertyDecorator.js';
+import { BaseObject } from '../../lib/base/BaseObject.js';
+import { Schema } from '../../lib/validation/types/Schema.js';
+/**
+ * Make the property an option of the object: its value is the option given in the object's declaration (`{class:
+ * MyComponent, port: 80}`) or to `getObject()`, else the property's initializer, else the default of its schema. The
+ * value is validated against the schema, then passed to `fn`, when the object is created: after its injections, before
+ * its `init()` runs. The declaration replaces an `@Inject` or `@Configurable` declaration of the property in a parent
+ * class. A module also checks the options of the objects it declares when it initializes, before creating them.
+ * @param schema The schema validating the value (it may convert it or give its default). Default `DTO.Any()`: any
+ * value, `undefined` included.
+ * @param fn A function called with the instance as `this` and the validated value, returning the value set to the
+ * property, of the same type (it may be async). Default: the validated value as it is.
+ * @returns The property decorator.
+ * @throws {InvalidObjectOptionsException} When a module initializes, if an option it declares for the object does not
+ * match the schema (all the invalid options are listed).
+ * @throws {InvalidValueException} When the object is created, if its value does not match the schema (the creation of
+ * the object rejects).
+ * @example
+ * ```typescript
+ * import {Application, Component, DTO} from 'lakutata'
+ * import {Configurable} from 'lakutata/decorator/di'
+ *
+ * class Server extends Component {
+ *     //80 unless the declaration gives a port
+ *     @Configurable(DTO.Number().integer().min(1).max(65535).optional().default(80))
+ *     protected readonly port!: number
+ *
+ *     //The initializer is the default, validated like a configured value
+ *     @Configurable(DTO.String().required())
+ *     protected readonly host: string = '127.0.0.1'
+ *
+ *     //The base URL is kept without its trailing slash
+ *     @Configurable(DTO.String().uri().optional().default('http://localhost'), (value: string): string => value.replace(/\/+$/, ''))
+ *     protected readonly baseURL!: string
+ *
+ *     protected async init(): Promise<void> {
+ *         console.log(`Listening on ${this.host}:${this.port} for ${this.baseURL}`)
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'server.app',
+ *     name: 'Server',
+ *     components: {
+ *         server: {class: Server, port: 8080, baseURL: 'https://example.com/'}
+ *     }
+ * }))
+ * ```
+ */
+export declare function Configurable<ClassPrototype extends BaseObject, DataType>(schema?: Schema<DataType>, fn?: (this: ClassPrototype, value: DataType) => DataType | Promise<DataType>): PropertyDecorator<ClassPrototype>;