@lakutata/core 1.0.60 → 3.0.0-beta.1

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

@@ -0,0 +1,278 @@
+import { DataValidator } from './DataValidator.js';
+import { ValidationOptions } from '../validation/interfaces/ValidationOptions.js';
+import { Schema } from '../validation/types/Schema.js';
+import { ObjectSchema } from '../validation/interfaces/ObjectSchema.js';
+import { type FromJsonSchemaOptions, type ToJsonSchemaOptions } from '../validation/JsonSchema.js';
+import { JSONSchema } from '../../types/JSONSchema.js';
+/**
+ * The base class of the data transfer objects: a class whose properties are declared with schemas (`@Expect`), and
+ * which validates its data when it is constructed and each time it is changed. Its static methods validate any value
+ * (`DTO.validate()`), build schemas (`DTO.String()`, `DTO.Object()`…), and convert the class schema to or from JSON
+ * Schema. A DTO class is also a schema wherever one is expected: `@Accept`, `@Return`, the input of the controller
+ * actions. The schemas built by `DTO` are strict: a value of the wrong type is rejected, not converted (the string `'5'`
+ * is not the number 5).
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class AddressDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public city!: string
+ *
+ *     @Expect(DTO.String().pattern(/^[0-9]{5}$/).optional())
+ *     public zip?: string
+ * }
+ *
+ * class CustomerDTO extends DTO {
+ *     @Expect(DTO.String().min(1).required())
+ *     public name!: string
+ *
+ *     @Expect(AddressDTO.required())
+ *     public address!: AddressDTO
+ * }
+ *
+ * //Validated when constructed, the unknown key "note" removed
+ * const customer: CustomerDTO = new CustomerDTO({name: 'Ada', address: {city: 'London'}, note: 'vip'})
+ * //Validated without an instance: the validated value, or an InvalidValueException
+ * const data: CustomerDTO = CustomerDTO.validate({name: 'Ada', address: {city: 'London'}})
+ * //Checked without exception
+ * console.log(customer.name, data.address.city, CustomerDTO.isValid({name: ''}))
+ * ```
+ */
+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.
+     * @param props The data of the DTO. Default: no data (`{}`).
+     * @throws {InvalidValueException} When the data does not match the class schema.
+     */
+    constructor(props?: Record<string, any>);
+    [prop: string | symbol]: any;
+    /**
+     * Resolve the arguments of the validation methods: the schema given, else the class schema (`this.Schema()`), and
+     * the validation options.
+     * @param schemaOrOptions The schema to validate against, or the validation options when no schema is given.
+     * @param options The validation options, when a schema is given. Default: no option (`{}`).
+     * @returns The schema and the options to validate with.
+     * @protected
+     */
+    protected static prepareValidation(schemaOrOptions?: Schema | ValidationOptions, options?: ValidationOptions): {
+        schema: Schema;
+        options: ValidationOptions;
+    };
+    /**
+     * Convert the class schema to a JSON Schema, for an API document or another validator. What JSON Schema cannot
+     * express (custom rules, references to other values) is dropped, so the JSON Schema may accept more values, never
+     * less.
+     * @param version The JSON Schema version to write. Default `'draft-2020-12'`.
+     * @param options The validation options the schema is used with, whether `$schema` is written, and the object
+     * receiving the shared schemas. Default: no option (`{}`).
+     * @returns A new JSON Schema.
+     * @throws {SchemaConversionException} When the version is unknown.
+     */
+    static toJsonSchema(version?: 'draft-2020-12' | 'draft-2019-09' | 'draft-07' | 'draft-04', options?: Omit<ToJsonSchemaOptions, 'target'>): JSONSchema;
+    /**
+     * Convert the class schema to an OpenAPI schema object, for the `components.schemas` of an OpenAPI document.
+     * @param version The OpenAPI version: `'3.0'` or `'3.1'`. Default `'3.1'`.
+     * @param options The validation options the schema is used with, and the object receiving the shared schemas.
+     * Default: no option (`{}`).
+     * @returns A new OpenAPI schema object.
+     */
+    static toOpenAPIJsonSchema(version?: '3.0' | '3.1', options?: Omit<ToJsonSchemaOptions, 'target' | 'dialect'>): JSONSchema;
+    /**
+     * Create a DTO class (a subclass of the current DTO class) from an object JSON Schema (or an OpenAPI schema object),
+     * validating like JSON Schema: its properties become the properties of the DTO, its other keywords (unknown keys,
+     * pattern properties, key counts, dependencies, subschemas) constrain the whole object.
+     * @param schema The JSON Schema of an object (or an OpenAPI schema object), or a reference (`$ref`) to one.
+     * @param options The version of the JSON Schema, where its references are resolved, whether the values are
+     * converted, and the name of the class. Default `name`: the title of the JSON Schema, else the current class
+     * name followed by `FromJsonSchema`.
+     * @returns The new DTO class.
+     * @throws {SchemaConversionException} When the JSON Schema does not describe objects, a reference cannot be
+     * resolved, or a pattern is not a valid regular expression.
+     */
+    static fromJsonSchema<T extends typeof DTO>(this: T, schema: JSONSchema, options?: FromJsonSchemaOptions & {
+        name?: string;
+    }): T;
+    /**
+     * Create the DTO classes of the object schemas of an OpenAPI document (its components.schemas), by name; the
+     * references between the schemas are resolved in the document. The schemas which do not describe objects are
+     * skipped.
+     * @param document The OpenAPI 3.0 or 3.1 document.
+     * @param options How the JSON Schemas are read. Default `dialect`: the version of the document's `openapi` field.
+     * @returns The DTO classes, by the names of their schemas.
+     * @throws {SchemaConversionException} When the document has no `components.schemas`, or a schema cannot be
+     * converted.
+     */
+    static fromOpenAPI<T extends typeof DTO>(this: T, document: Record<string, unknown>, options?: Omit<FromJsonSchemaOptions, 'document'>): Record<string, T>;
+    /**
+     * Set the description of the class schema, written into its JSON Schema and its descriptions. The description is
+     * not inherited by the subclasses.
+     * @param desc The description.
+     * @returns The class itself, for chaining.
+     */
+    static description(desc: string): typeof DTO;
+    /**
+     * Get the class schema: an object schema of the properties declared with `@Expect` (the parents' included), with
+     * the `@IndexSignature` and the description of the class. The schema is optional (it accepts `undefined`): use
+     * `required()` for a required one.
+     * @returns The object schema; the same instance until a schema declaration changes.
+     */
+    static Schema(): ObjectSchema;
+    /**
+     * Get the class schema marked as required: `undefined` is rejected.
+     * @returns A new object schema.
+     */
+    static required(): ObjectSchema;
+    /**
+     * Get the class schema marked as optional: `undefined` is accepted (as by `Schema()`).
+     * @returns A new object schema.
+     */
+    static optional(): ObjectSchema;
+    /**
+     * Get the class schema with its own validation options, which override the options of the validation for the
+     * object and its nested values.
+     * @param options The validation options.
+     * @returns A new object schema.
+     */
+    static options(options: ValidationOptions): ObjectSchema;
+    /**
+     * Check whether a value matches a schema (the class schema when none is given), without throwing.
+     * @param data The value to check.
+     * @returns `true` when the value matches the schema, else `false`.
+     */
+    static isValid<T = any>(data: T): boolean;
+    /**
+     * Check whether a value matches a schema (the class schema when none is given), without throwing.
+     * @param data The value to check.
+     * @param options The validation options, merged with the defaults (unknown keys removed, the first error only).
+     * @returns `true` when the value matches the schema, else `false`.
+     */
+    static isValid<T = any>(data: T, options: ValidationOptions): boolean;
+    /**
+     * Check whether a value matches a schema (the class schema when none is given), without throwing.
+     * @param data The value to check.
+     * @param schema The schema to check against, instead of the class schema.
+     * @returns `true` when the value matches the schema, else `false`.
+     */
+    static isValid<T = any>(data: T, schema: Schema): boolean;
+    /**
+     * Check whether a value matches a schema (the class schema when none is given), without throwing.
+     * @param data The value to check.
+     * @param schema The schema to check against, instead of the class schema.
+     * @param options The validation options, merged with the defaults (unknown keys removed, the first error only).
+     * @returns `true` when the value matches the schema, else `false`.
+     */
+    static isValid<T = any>(data: T, schema: Schema, options: ValidationOptions): boolean;
+    /**
+     * Check whether a value matches a schema (the class schema when none is given), without throwing; asynchronously,
+     * running the external rules of the schema.
+     * @param data The value to check.
+     * @returns A promise of `true` when the value matches the schema, else `false`.
+     */
+    static isValidAsync<T = any>(data: T): Promise<boolean>;
+    /**
+     * Check whether a value matches a schema (the class schema when none is given), without throwing; asynchronously,
+     * running the external rules of the schema.
+     * @param data The value to check.
+     * @param options The validation options, merged with the defaults (unknown keys removed, the first error only).
+     * @returns A promise of `true` when the value matches the schema, else `false`.
+     */
+    static isValidAsync<T = any>(data: T, options: ValidationOptions): Promise<boolean>;
+    /**
+     * Check whether a value matches a schema (the class schema when none is given), without throwing; asynchronously,
+     * running the external rules of the schema.
+     * @param data The value to check.
+     * @param schema The schema to check against, instead of the class schema.
+     * @returns A promise of `true` when the value matches the schema, else `false`.
+     */
+    static isValidAsync<T = any>(data: T, schema: Schema): Promise<boolean>;
+    /**
+     * Check whether a value matches a schema (the class schema when none is given), without throwing; asynchronously,
+     * running the external rules of the schema.
+     * @param data The value to check.
+     * @param schema The schema to check against, instead of the class schema.
+     * @param options The validation options, merged with the defaults (unknown keys removed, the first error only).
+     * @returns A promise of `true` when the value matches the schema, else `false`.
+     */
+    static isValidAsync<T = any>(data: T, schema: Schema, options: ValidationOptions): Promise<boolean>;
+    /**
+     * Validate a value against a schema (the class schema when none is given).
+     * @param data The value to check.
+     * @returns The validated value: the defaults applied, the unknown keys removed (a plain object, not a DTO instance).
+     * @throws {InvalidValueException} When the value does not match the schema (its cause holds the details).
+     */
+    static validate<T = any>(data: T): T;
+    /**
+     * Validate a value against a schema (the class schema when none is given).
+     * @param data The value to check.
+     * @param options The validation options, merged with the defaults (unknown keys removed, the first error only).
+     * @returns The validated value: the defaults applied, the unknown keys removed (a plain object, not a DTO instance).
+     * @throws {InvalidValueException} When the value does not match the schema (its cause holds the details).
+     */
+    static validate<T = any>(data: T, options: ValidationOptions): T;
+    /**
+     * Validate a value against a schema (the class schema when none is given).
+     * @param data The value to check.
+     * @param schema The schema to check against, instead of the class schema.
+     * @returns The validated value: the defaults applied, the unknown keys removed (a plain object, not a DTO instance).
+     * @throws {InvalidValueException} When the value does not match the schema (its cause holds the details).
+     */
+    static validate<T = any>(data: T, schema: Schema): T;
+    /**
+     * Validate a value against a schema (the class schema when none is given).
+     * @param data The value to check.
+     * @param schema The schema to check against, instead of the class schema.
+     * @param options The validation options, merged with the defaults (unknown keys removed, the first error only).
+     * @returns The validated value: the defaults applied, the unknown keys removed (a plain object, not a DTO instance).
+     * @throws {InvalidValueException} When the value does not match the schema (its cause holds the details).
+     */
+    static validate<T = any>(data: T, schema: Schema, options: ValidationOptions): T;
+    /**
+     * Validate a value against a schema (the class schema when none is given), asynchronously: the external rules of
+     * the schema (`.external()`) run, which the synchronous validation cannot run.
+     * @param data The value to check.
+     * @returns A promise of the validated value: the defaults applied, the unknown keys removed (a plain object, not a DTO
+     * instance).
+     * @throws {InvalidValueException} When the value does not match the schema (the promise rejects; its cause holds
+     * the details).
+     */
+    static validateAsync<T = any>(data: T): Promise<T>;
+    /**
+     * Validate a value against a schema (the class schema when none is given), asynchronously: the external rules of
+     * the schema (`.external()`) run, which the synchronous validation cannot run.
+     * @param data The value to check.
+     * @param options The validation options, merged with the defaults (unknown keys removed, the first error only).
+     * @returns A promise of the validated value: the defaults applied, the unknown keys removed (a plain object, not a DTO
+     * instance).
+     * @throws {InvalidValueException} When the value does not match the schema (the promise rejects; its cause holds
+     * the details).
+     */
+    static validateAsync<T = any>(data: T, options: ValidationOptions): Promise<T>;
+    /**
+     * Validate a value against a schema (the class schema when none is given), asynchronously: the external rules of
+     * the schema (`.external()`) run, which the synchronous validation cannot run.
+     * @param data The value to check.
+     * @param schema The schema to check against, instead of the class schema.
+     * @returns A promise of the validated value: the defaults applied, the unknown keys removed (a plain object, not a DTO
+     * instance).
+     * @throws {InvalidValueException} When the value does not match the schema (the promise rejects; its cause holds
+     * the details).
+     */
+    static validateAsync<T = any>(data: T, schema: Schema): Promise<T>;
+    /**
+     * Validate a value against a schema (the class schema when none is given), asynchronously: the external rules of
+     * the schema (`.external()`) run, which the synchronous validation cannot run.
+     * @param data The value to check.
+     * @param schema The schema to check against, instead of the class schema.
+     * @param options The validation options, merged with the defaults (unknown keys removed, the first error only).
+     * @returns A promise of the validated value: the defaults applied, the unknown keys removed (a plain object, not a DTO
+     * instance).
+     * @throws {InvalidValueException} When the value does not match the schema (the promise rejects; its cause holds
+     * the details).
+     */
+    static validateAsync<T = any>(data: T, schema: Schema, options: ValidationOptions): Promise<T>;
+}

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

@@ -0,0 +1,166 @@
+import 'reflect-metadata';
+import { AnySchema } from '../validation/interfaces/AnySchema.js';
+import type { Description } from '../validation/interfaces/Description.js';
+import { StringSchema } from '../validation/interfaces/StringSchema.js';
+import { NumberSchema } from '../validation/interfaces/NumberSchema.js';
+import { BooleanSchema } from '../validation/interfaces/BooleanSchema.js';
+import { DateSchema } from '../validation/interfaces/DateSchema.js';
+import { SchemaLikeWithoutArray } from '../validation/types/SchemaLikeWithoutArray.js';
+import { ArraySchema } from '../validation/interfaces/ArraySchema.js';
+import { SchemaMap } from '../validation/types/SchemaMap.js';
+import { ObjectSchema } from '../validation/interfaces/ObjectSchema.js';
+import { Schema } from '../validation/types/Schema.js';
+import { ValidationOptions } from '../validation/interfaces/ValidationOptions.js';
+import { SchemaLike } from '../validation/types/SchemaLike.js';
+import { AlternativesSchema } from '../validation/interfaces/AlternativesSchema.js';
+import { SymbolSchema } from '../validation/interfaces/SymbolSchema.js';
+import { FunctionSchema } from '../validation/interfaces/FunctionSchema.js';
+import { BinarySchema } from '../validation/interfaces/BinarySchema.js';
+import { ReferenceOptions } from '../validation/interfaces/ReferenceOptions.js';
+import { Reference } from '../validation/interfaces/Reference.js';
+import { LinkSchema } from '../validation/interfaces/LinkSchema.js';
+import { BigIntSchema } from '../validation/interfaces/BigIntSchema.js';
+import { type CronOptions } from '../../types/CronOptions.js';
+export declare class DataValidator {
+    /**
+     * Rebuild a schema from its description (the output of `schema.describe()`), exactly.
+     * @param description The description of the schema.
+     * @returns The schema.
+     */
+    static Build<TSchema = any>(description: Description): Schema<TSchema>;
+    /**
+     * Build a schema accepting any value (`undefined` included unless marked `required()`).
+     * @returns A new schema.
+     */
+    static Any<TSchema = any>(): AnySchema<TSchema>;
+    /**
+     * Build a schema of strings; strict: a value of another type is rejected, not converted.
+     * @returns A new string schema.
+     */
+    static String<TSchema = string>(): StringSchema<TSchema>;
+    /**
+     * Build a schema of numbers; strict: a value of another type is rejected, not converted (the string `'5'` is not
+     * the number 5).
+     * @returns A new number schema.
+     */
+    static Number<TSchema = number>(): NumberSchema<TSchema>;
+    /**
+     * Build a schema of bigints; strict: a value of another type is rejected, not converted.
+     * @returns A new bigint schema.
+     */
+    static BigInt<TSchema = bigint>(): BigIntSchema<TSchema>;
+    /**
+     * Build a schema of booleans; strict: a value of another type is rejected, not converted (the string `'true'` is
+     * not a boolean).
+     * @returns A new boolean schema.
+     */
+    static Boolean<TSchema = boolean>(): BooleanSchema<TSchema>;
+    /**
+     * Build a schema of `Date` objects; strict: a value of another type is rejected, not converted (a date string or a
+     * timestamp is not a date).
+     * @returns A new date schema.
+     */
+    static Date<TSchema = Date>(): DateSchema<TSchema>;
+    /**
+     * Build a schema of objects, with the schemas of their keys; strict. With the default validation options, the keys
+     * without schema are removed.
+     * @param schema The schemas of the keys, by key. Default: no key declared.
+     * @returns A new object schema.
+     */
+    static Object<TSchema = any, isStrict = false, T = TSchema>(schema?: SchemaMap<T, isStrict>): ObjectSchema<TSchema>;
+    /**
+     * Build a schema of arrays whose items match one of the schemas given; strict.
+     * @param types The schemas an item may match. Default: any item.
+     * @returns A new array schema.
+     */
+    static Array<TSchema = any[]>(...types: SchemaLikeWithoutArray[]): ArraySchema<TSchema>;
+    /**
+     * Build a schema of `Buffer`s; strict: a value of another type is rejected, not converted.
+     * @returns A new binary schema.
+     */
+    static Binary<TSchema = Buffer>(): BinarySchema<TSchema>;
+    /**
+     * Build a schema of functions; strict.
+     * @returns A new function schema.
+     */
+    static Function<TSchema = Function>(): FunctionSchema<TSchema>;
+    /**
+     * Build a schema of async functions (declared `async`); a function which only returns a promise is rejected.
+     * @returns A new function schema.
+     */
+    static AsyncFunction<TSchema = Function>(): FunctionSchema<TSchema>;
+    /**
+     * Build a schema of classes, optionally of the subclasses of a class.
+     * @param inheritsFrom The class the value must be or extend, or a function returning it (for a class declared
+     * later). Default: any class.
+     * @returns A new function schema.
+     */
+    static Class<TSchema = Function>(inheritsFrom?: TSchema | (() => TSchema)): FunctionSchema<TSchema>;
+    /**
+     * Build a schema of the instances of a class (the instances of its subclasses included).
+     * @param constructor The class.
+     * @returns A new schema.
+     */
+    static InstanceOf<TSchema = Function>(constructor: TSchema): AnySchema<TSchema>;
+    /**
+     * Build a schema of glob pattern strings (`*.ts`, `src/**`).
+     * @returns A new string schema.
+     */
+    static Glob<TSchema = string>(): StringSchema<TSchema>;
+    /**
+     * Build a schema of cron expression strings. The options not given default to: seconds allowed (6 fields), `?`
+     * allowed for a day, 7 accepted as Sunday, no aliases (`@daily`).
+     * @param options The cron syntax accepted.
+     * @returns A new string schema.
+     */
+    static Cron<TSchema = string>(options?: CronOptions): StringSchema<TSchema>;
+    /**
+     * Build a schema of HTML or XML document strings.
+     * @returns A new string schema.
+     */
+    static HttpDocument<TSchema = string>(): StringSchema<TSchema>;
+    /**
+     * Build a schema of symbols; strict.
+     * @returns A new symbol schema.
+     */
+    static Symbol<TSchema = Symbol>(): SymbolSchema<TSchema>;
+    /**
+     * Build a schema matching a value against several schemas, in order: the first one matching validates it.
+     * @param types The schemas tried in order.
+     * @returns A new alternatives schema.
+     */
+    static Alternatives<TSchema = any>(...types: SchemaLike[]): AlternativesSchema<TSchema>;
+    /**
+     * Create a reference to another value of the validated object (a sibling key by default), resolved at validation,
+     * for the rules comparing values (`DTO.Number().greater(DTO.Ref('min'))`).
+     * @param key The path of the referenced value: a key, `a.b` for a nested key, `/key` from the root.
+     * @param options How the reference is resolved.
+     * @returns The reference.
+     */
+    static Ref(key: string, options?: ReferenceOptions): Reference;
+    /**
+     * Create a reference to an array of the validated object, whose items are the values allowed, for `valid()` or
+     * `invalid()`.
+     * @param ref The path of the referenced array.
+     * @param options How the reference is resolved.
+     * @returns The reference.
+     */
+    static In(ref: string, options?: ReferenceOptions): Reference;
+    /**
+     * Validate a value against a schema and return the validated value. Unlike `DTO.validate()`, the default options of
+     * lakutata are not applied: an unknown key is rejected, not removed.
+     * @param value The value to validate.
+     * @param schema The schema to validate against.
+     * @param options The validation options.
+     * @returns The validated value.
+     * @throws {SchemaValidationException} When the value does not match the schema.
+     */
+    static Attempt<TSchema extends Schema>(value: any, schema: TSchema, options?: ValidationOptions): TSchema extends Schema<infer Value> ? Value : never;
+    /**
+     * Build a schema linking to another schema of the same tree, for the recursive structures (a tree of nodes): `#id`
+     * for the schema given that id, `/` for the root, `...` for an ancestor.
+     * @param ref The path of the linked schema.
+     * @returns A new link schema.
+     */
+    static Link<TSchema extends Schema>(ref: string): LinkSchema<TSchema>;
+}

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

@@ -0,0 +1,23 @@
+import { DTO } from './DTO.js';
+/**
+ * A DTO accepting any key: the keys without an `@Expect` schema are kept, whatever their values (`@IndexSignature` with
+ * `DTO.Any()`), instead of removed. Extend it for the data whose keys are not all known, while validating the known ones.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {FlexibleDTO} from 'lakutata/dtos'
+ *
+ * //An event: its type is validated, its other fields are kept as they are
+ * class EventDTO extends FlexibleDTO {
+ *     @Expect(DTO.String().required())
+ *     public type!: string
+ * }
+ *
+ * const event: EventDTO = new EventDTO({type: 'login', user: 'ada', at: Date.now()})
+ * console.log(event.user)
+ * ```
+ */
+export declare class FlexibleDTO extends DTO {
+    [prop: string]: any;
+}

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

@@ -0,0 +1,44 @@
+import { DTO } from './DTO.js';
+import { Schema } from '../validation/types/Schema.js';
+/**
+ * For validate method accept arguments
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param defs
+ * @constructor
+ */
+export declare function setMethodAcceptArgumentsValidator<ClassPrototype, DTOConstructor extends typeof DTO>(target: ClassPrototype, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>, defs: (DTOConstructor | Schema)[]): TypedPropertyDescriptor<any>;
+/**
+ * Get the schema a method's result is validated against, declared with `@Return` (the schema of a DTO class given to
+ * `@Return`); used by the entrypoint channels describing the results of their actions. It is looked up through the
+ * prototype chain: a subclass gets the schema of its parent's method, even when it overrides the method.
+ * @param target The prototype of the class.
+ * @param propertyKey The name of the method.
+ * @returns The schema, or `undefined` when the method has no `@Return`.
+ * @example
+ * ```typescript
+ * import {Component, DTO} from 'lakutata'
+ * import {getMethodReturnSchema, Return} from 'lakutata/decorator/dto'
+ *
+ * class Clock extends Component {
+ *     @Return(DTO.Number().integer().required())
+ *     public async now(): Promise<number> {
+ *         return Date.now()
+ *     }
+ * }
+ *
+ * //The description of the result, e.g. for a generated API document
+ * console.log(getMethodReturnSchema(Clock.prototype, 'now')?.describe())
+ * ```
+ */
+export declare function getMethodReturnSchema(target: object, propertyKey: string | symbol): Schema | undefined;
+/**
+ * For validate method return value
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param def
+ * @constructor
+ */
+export declare function setMethodReturnValueValidator<ClassPrototype, DTOConstructor extends typeof DTO>(target: ClassPrototype, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>, def: DTOConstructor | Schema): TypedPropertyDescriptor<any>;

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

@@ -0,0 +1,86 @@
+import { DTO } from './DTO.js';
+import { Schema } from '../validation/types/Schema.js';
+import { ObjectSchema } from '../validation/interfaces/ObjectSchema.js';
+import { type CachedSchema } from './CachedSchema.js';
+export type ObjectPropertySchemaMap = Map<string, Schema>;
+/**
+ * Adds the class-level constraints of a DTO to the object schema of its properties
+ */
+export type ObjectSchemaRefinement = (schema: ObjectSchema) => ObjectSchema;
+/**
+ * Invalidate every cached DTO schema
+ * @constructor
+ */
+export declare function invalidateDTOSchemas(): void;
+/**
+ * Get a value cached per DTO class, built again after any schema definition change
+ * @param cache
+ * @param target
+ * @param build
+ * @constructor
+ */
+export declare function getCachedDTOSchema<T>(cache: WeakMap<Function, CachedSchema<T>>, target: Function, build: () => T): T;
+/**
+ * Define DTO
+ * @param target
+ * @constructor
+ */
+export declare function defineObjectAsDTO<ClassConstructor extends typeof DTO>(target: ClassConstructor): ClassConstructor;
+/**
+ * Check the target constructor is DTO constructor or not
+ * @param target
+ * @constructor
+ */
+export declare function isDTO<ClassConstructor extends typeof DTO>(target: ClassConstructor): boolean;
+/**
+ * Set object index signature schema
+ * @param target
+ * @param schema
+ * @constructor
+ */
+export declare function setObjectIndexSignatureSchema<ClassConstructor extends typeof DTO>(target: ClassConstructor, schema: Schema): ClassConstructor;
+/**
+ * Get object's index signature schema by its prototype
+ * @param target
+ * @constructor
+ */
+export declare function getObjectIndexSignatureSchemaByPrototype<ClassPrototype extends DTO>(target: ClassPrototype): Schema | null;
+/**
+ * Get object's index signature schema by its constructor
+ * @param target
+ * @constructor
+ */
+export declare function getObjectIndexSignatureSchemaByConstructor<ClassConstructor extends typeof DTO>(target: ClassConstructor): Schema | null;
+/**
+ * Set data validation schema to object's property
+ * @param target
+ * @param propertyKey
+ * @param schema
+ * @constructor
+ */
+export declare function setObjectPropertySchema<ClassPrototype extends DTO>(target: ClassPrototype, propertyKey: string | symbol, schema: Schema): void;
+/**
+ * Get object's property schemas by its prototype
+ * @param target
+ * @constructor
+ */
+export declare function getObjectPropertySchemas<ClassPrototype extends DTO>(target: ClassPrototype): ObjectPropertySchemaMap;
+/**
+ * Get DTO object schema by its prototype
+ * @param target
+ * @constructor
+ */
+export declare function getObjectSchemaByPrototype<ClassPrototype extends DTO>(target: ClassPrototype): ObjectSchema;
+/**
+ * Get DTO object schema by its constructor
+ * @param target
+ * @constructor
+ */
+export declare function getObjectSchemaByConstructor<ClassConstructor extends typeof DTO>(target: ClassConstructor): ObjectSchema;
+/**
+ * Set the class-level constraints of a DTO (applied to the object schema of its properties, inherited by its subclasses)
+ * @param target
+ * @param refinement
+ * @constructor
+ */
+export declare function setObjectSchemaRefinement<ClassConstructor extends typeof DTO>(target: ClassConstructor, refinement: ObjectSchemaRefinement): ClassConstructor;

package/dist/types/lib/dto/internal/CronValidator.d.ts

@@ -0,0 +1,8 @@
+import { type CronOptions } from '../../../types/CronOptions.js';
+/**
+ * Whether a cron expression is valid: five fields (minutes, hours, days, months, weekdays), or six with the seconds
+ * first when they are allowed
+ * @param cron
+ * @param partialOptions
+ */
+export declare function isValidCron(cron: string, partialOptions?: CronOptions): boolean;

package/dist/types/lib/foundation/BasicInfo.d.ts

@@ -0,0 +1,46 @@
+type BasicInfo = {
+    appId: string;
+    appName: string;
+    timezone: string;
+    mode: 'development' | 'production';
+};
+/**
+ * The mode of the application: the environment overrides the options (the same build runs in each mode). The one of
+ * the MODE environment variable (the one of lakutata), of NODE_ENV, of the options, development otherwise. A MODE
+ * which is not a mode is warned of and left; a NODE_ENV which is not a mode (test) is left
+ * @param configured the mode of the options of the application
+ */
+export declare function resolveMode(configured?: 'development' | 'production'): 'development' | 'production';
+/**
+ * The mode of the application running: the one written to MODE and NODE_ENV when it launched, development otherwise
+ */
+export declare function currentMode(): 'development' | 'production';
+/**
+ * Whether passed timezone parameter is a valid timezone string or not
+ * If passed timezone is valid, return the timezone string, else return default timezone string
+ * @param timezone
+ * @constructor
+ */
+export declare function validateTimezone(timezone: string): string;
+/**
+ * Set application basic info
+ * @param info
+ * @constructor
+ */
+export declare function setBasicInfo(info: BasicInfo): BasicInfo;
+/**
+ * Get application id (reads a single environment variable, much cheaper than getBasicInfo())
+ * @constructor
+ */
+export declare function getAppId(): string;
+/**
+ * Get application name (reads a single environment variable, much cheaper than getBasicInfo())
+ * @constructor
+ */
+export declare function getAppName(): string;
+/**
+ * Get application basic info
+ * @constructor
+ */
+export declare function getBasicInfo(): BasicInfo;
+export {};