@archbase/core 3.0.0

package/dist/validator/decorator/string/IsUppercase.d.ts

@@ -0,0 +1,12 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_UPPERCASE = "isUppercase";
+/**
+ * Checks if the string is uppercase.
+ * If given value is not a string, then it returns false.
+ */
+export declare function isUppercase(value: unknown): boolean;
+/**
+ * Checks if the string is uppercase.
+ * If given value is not a string, then it returns false.
+ */
+export declare function IsUppercase(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/IsUrl.d.ts

@@ -0,0 +1,12 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_URL = "isUrl";
+/**
+ * Checks if the string is a url.
+ * If given value is not a string, then it returns false.
+ */
+export declare function isURL(value: string, options?: validator.IsURLOptions): boolean;
+/**
+ * Checks if the string is a url.
+ * If given value is not a string, then it returns false.
+ */
+export declare function IsUrl(options?: validator.IsURLOptions, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/IsVariableWidth.d.ts

@@ -0,0 +1,12 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_VARIABLE_WIDTH = "isVariableWidth";
+/**
+ * Checks if the string contains variable-width chars.
+ * If given value is not a string, then it returns false.
+ */
+export declare function isVariableWidth(value: unknown): boolean;
+/**
+ * Checks if the string contains variable-width chars.
+ * If given value is not a string, then it returns false.
+ */
+export declare function IsVariableWidth(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/Length.d.ts

@@ -0,0 +1,12 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_LENGTH = "isLength";
+/**
+ * Checks if the string's length falls in a range. Note: this function takes into account surrogate pairs.
+ * If given value is not a string, then it returns false.
+ */
+export declare function length(value: unknown, min: number, max?: number): boolean;
+/**
+ * Checks if the string's length falls in a range. Note: this function takes into account surrogate pairs.
+ * If given value is not a string, then it returns false.
+ */
+export declare function Length(min: number, max?: number, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/Matches.d.ts

@@ -0,0 +1,14 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const MATCHES = "matches";
+/**
+ * Checks if string matches the pattern. Either matches('foo', /foo/i).
+ * If given value is not a string, then it returns false.
+ */
+export declare function matches(value: string, pattern: RegExp): boolean;
+export declare function matches(value: string, pattern: string, modifiers: string): boolean;
+/**
+ * Checks if string matches the pattern. Either matches('foo', /foo/i)
+ * If given value is not a string, then it returns false.
+ */
+export declare function Matches(pattern: RegExp, validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function Matches(pattern: string, modifiers?: string, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/MaxLength.d.ts

@@ -0,0 +1,12 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const MAX_LENGTH = "maxLength";
+/**
+ * Checks if the string's length is not more than given number. Note: this function takes into account surrogate pairs.
+ * If given value is not a string, then it returns false.
+ */
+export declare function maxLength(value: unknown, max: number): boolean;
+/**
+ * Checks if the string's length is not more than given number. Note: this function takes into account surrogate pairs.
+ * If given value is not a string, then it returns false.
+ */
+export declare function MaxLength(max: number, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/MinLength.d.ts

@@ -0,0 +1,12 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const MIN_LENGTH = "minLength";
+/**
+ * Checks if the string's length is not less than given number. Note: this function takes into account surrogate pairs.
+ * If given value is not a string, then it returns false.
+ */
+export declare function minLength(value: unknown, min: number): boolean;
+/**
+ * Checks if the string's length is not less than given number. Note: this function takes into account surrogate pairs.
+ * If given value is not a string, then it returns false.
+ */
+export declare function MinLength(min: number, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/NotContains.d.ts

@@ -0,0 +1,12 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const NOT_CONTAINS = "notContains";
+/**
+ * Checks if the string does not contain the seed.
+ * If given value is not a string, then it returns false.
+ */
+export declare function notContains(value: unknown, seed: string): boolean;
+/**
+ * Checks if the string does not contain the seed.
+ * If given value is not a string, then it returns false.
+ */
+export declare function NotContains(seed: string, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/is-iso4217-currency-code.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_ISO4217_CURRENCY_CODE = "isISO4217CurrencyCode";
+/**
+ * Check if the string is a valid [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) officially assigned currency code.
+ */
+export declare function isISO4217CurrencyCode(value: unknown): boolean;
+/**
+ * Check if the string is a valid [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) officially assigned currency code.
+ */
+export declare function IsISO4217CurrencyCode(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/string/is-tax-id.d.ts

@@ -0,0 +1,20 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_TAX_ID = "isTaxId";
+/**
+ * Checks if the string is a valid tax ID. Default locale is `en-US`.
+ * If given value is not a string, then it returns false.
+ *
+ * Supported locales: bg-BG, cs-CZ, de-AT, de-DE, dk-DK, el-CY, el-GR, en-CA,
+ * en-IE, en-US, es-ES, et-EE, fi-FI, fr-BE, fr-FR, fr-LU, hr-HR, hu-HU, it-IT,
+ * lv-LV, mt-MT, nl-NL, pl-PL, pt-BR, pt-PT, ro-RO, sk-SK, sl-SI, sv-SE.
+ */
+export declare function isTaxId(value: unknown, locale?: string): boolean;
+/**
+ * Checks if the string is a valid tax ID. Default locale is `en-US`.
+ * If given value is not a string, then it returns false.
+ *
+ * Supported locales: bg-BG, cs-CZ, de-AT, de-DE, dk-DK, el-CY, el-GR, en-CA,
+ * en-IE, en-US, es-ES, et-EE, fi-FI, fr-BE, fr-FR, fr-LU, hr-HR, hu-HU, it-IT,
+ * lv-LV, mt-MT, nl-NL, pl-PL, pt-BR, pt-PT, ro-RO, sk-SK, sl-SI, sv-SE.
+ */
+export declare function IsTaxId(locale?: string, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/typechecker/IsArray.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_ARRAY = "isArray";
+/**
+ * Checks if a given value is an array
+ */
+export declare function isArray<T = any>(value: unknown): value is Array<T>;
+/**
+ * Checks if a given value is an array
+ */
+export declare function IsArray(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/typechecker/IsBoolean.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_BOOLEAN = "isBoolean";
+/**
+ * Checks if a given value is a boolean.
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if a value is a boolean.
+ */
+export declare function IsBoolean(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/typechecker/IsDate.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_DATE = "isDate";
+/**
+ * Checks if a given value is a date.
+ */
+export declare function isDate(value: unknown): value is Date;
+/**
+ * Checks if a value is a date.
+ */
+export declare function IsDate(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/typechecker/IsEnum.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_ENUM = "isEnum";
+/**
+ * Checks if a given value is the member of the provided enum.
+ */
+export declare function isEnum(value: unknown, entity: any): boolean;
+/**
+ * Checks if a given value is the member of the provided enum.
+ */
+export declare function IsEnum(entity: object, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/typechecker/IsInt.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_INT = "isInt";
+/**
+ * Checks if value is an integer.
+ */
+export declare function isInt(val: unknown): val is Number;
+/**
+ * Checks if value is an integer.
+ */
+export declare function IsInt(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/typechecker/IsNumber.d.ts

@@ -0,0 +1,18 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_NUMBER = "isNumber";
+/**
+ * Options to be passed to IsNumber decorator.
+ */
+export interface IsNumberOptions {
+    allowNaN?: boolean;
+    allowInfinity?: boolean;
+    maxDecimalPlaces?: number;
+}
+/**
+ * Checks if a given value is a number.
+ */
+export declare function isNumber(value: unknown, options?: IsNumberOptions): value is number;
+/**
+ * Checks if a value is a number.
+ */
+export declare function IsNumber(options?: IsNumberOptions, validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/typechecker/IsObject.d.ts

@@ -0,0 +1,12 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_OBJECT = "isObject";
+/**
+ * Checks if the value is valid Object.
+ * Returns false if the value is not an object.
+ */
+export declare function isObject<T = object>(value: unknown): value is T;
+/**
+ * Checks if the value is valid Object.
+ * Returns false if the value is not an object.
+ */
+export declare function IsObject(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/decorator/typechecker/IsString.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions } from '../ValidationOptions';
+export declare const IS_STRING = "isString";
+/**
+ * Checks if a given value is a real string.
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Checks if a given value is a real string.
+ */
+export declare function IsString(validationOptions?: ValidationOptions): PropertyDecorator;

package/dist/validator/index.d.ts

@@ -0,0 +1,49 @@
+import { ValidationError } from './validation/ValidationError';
+import { ValidatorOptions } from './validation/ValidatorOptions';
+import { ValidationSchema } from './validation-schema/ValidationSchema';
+export * from './container';
+export * from './decorator/decorators';
+export * from './decorator/ValidationOptions';
+export * from './validation/ValidatorConstraintInterface';
+export * from './validation/ValidationError';
+export * from './validation/ValidatorOptions';
+export * from './validation/ValidationArguments';
+export * from './validation/ValidationTypes';
+export * from './validation/Validator';
+export * from './validation-schema/ValidationSchema';
+export * from './register-decorator';
+export * from './metadata/MetadataStorage';
+export { ArchbaseValidator } from './ArchbaseValidator';
+export type { DataSourceValidationError, IDataSourceValidator } from './ArchbaseValidator';
+/**
+ * Valida determinado objeto.
+ */
+export declare function validate(object: object, validatorOptions?: ValidatorOptions): Promise<ValidationError[]>;
+/**
+ * Valida determinado objeto por um determinado esquema de validação.
+ */
+export declare function validate(schemaName: string, object: object, validatorOptions?: ValidatorOptions): Promise<ValidationError[]>;
+/**
+ * Valida determinado objeto e rejeita em caso de erro.
+ */
+export declare function validateOrReject(object: object, validatorOptions?: ValidatorOptions): Promise<void>;
+/**
+ * Valida determinado objeto por um determinado esquema de validação e rejeita em caso de erro.
+ */
+export declare function validateOrReject(schemaName: string, object: object, validatorOptions?: ValidatorOptions): Promise<void>;
+/**
+ * Executa a validação de sincronização do objeto fornecido.
+ * Observe que este método ignora completamente as validações assíncronas.
+ * Se você deseja realizar a validação corretamente, você precisa chamar o método activate.
+ */
+export declare function validateSync(object: object, validatorOptions?: ValidatorOptions): ValidationError[];
+/**
+ * Valida determinado objeto por um determinado esquema de validação.
+ * Observe que este método ignora completamente as validações assíncronas.
+ * Se você deseja realizar a validação corretamente, você precisa chamar o método activate.
+ */
+export declare function validateSync(schemaName: string, object: object, validatorOptions?: ValidatorOptions): ValidationError[];
+/**
+ * Registra um novo esquema de validação.
+ */
+export declare function registerSchema(schema: ValidationSchema): void;

package/dist/validator/metadata/ConstraintMetadata.d.ts

@@ -0,0 +1,23 @@
+import { ValidatorConstraintInterface } from '../validation/ValidatorConstraintInterface';
+/**
+ * This metadata interface contains information for custom validators.
+ */
+export declare class ConstraintMetadata {
+    /**
+     * Target class which performs validation.
+     */
+    target: Function;
+    /**
+     * Custom validation's name, that will be used as validation error type.
+     */
+    name?: string;
+    /**
+     * Indicates if this validation is asynchronous or not.
+     */
+    async: boolean;
+    constructor(target: Function, name?: string, async?: boolean);
+    /**
+     * Instance of the target custom validation class which performs validation.
+     */
+    get instance(): ValidatorConstraintInterface;
+}

package/dist/validator/metadata/MetadataStorage.d.ts

@@ -0,0 +1,42 @@
+import { ValidationMetadata } from './ValidationMetadata';
+import { ConstraintMetadata } from './ConstraintMetadata';
+import { ValidationSchema } from '../validation-schema/ValidationSchema';
+/**
+ * Storage all metadatas.
+ */
+export declare class MetadataStorage {
+    private validationMetadatas;
+    private constraintMetadatas;
+    get hasValidationMetaData(): boolean;
+    /**
+     * Adds a new validation metadata.
+     */
+    addValidationSchema(schema: ValidationSchema): void;
+    /**
+     * Adds a new validation metadata.
+     */
+    addValidationMetadata(metadata: ValidationMetadata): void;
+    /**
+     * Adds a new constraint metadata.
+     */
+    addConstraintMetadata(metadata: ConstraintMetadata): void;
+    /**
+     * Groups metadata by their property names.
+     */
+    groupByPropertyName(metadata: ValidationMetadata[]): {
+        [propertyName: string]: ValidationMetadata[];
+    };
+    /**
+     * Gets all validation metadatas for the given object with the given groups.
+     */
+    getTargetValidationMetadatas(targetConstructor: Function, targetSchema: string, always: boolean, strictGroups: boolean, groups?: string[]): ValidationMetadata[];
+    /**
+     * Gets all validator constraints for the given object.
+     */
+    getTargetValidatorConstraints(target: Function): ConstraintMetadata[];
+}
+/**
+ * Gets metadata storage.
+ * Metadata storage follows the best practices and stores metadata in a global variable.
+ */
+export declare function getMetadataStorage(): MetadataStorage;

package/dist/validator/metadata/ValidationMetadata.d.ts

@@ -0,0 +1,53 @@
+import { ValidationMetadataArgs } from './ValidationMetadataArgs';
+import { ValidationArguments } from '../validation/ValidationArguments';
+/**
+ * This metadata contains validation rules.
+ */
+export declare class ValidationMetadata {
+    /**
+     * Validation type.
+     */
+    type: string;
+    /**
+     * Validator name.
+     */
+    name?: string;
+    /**
+     * Target class to which this validation is applied.
+     */
+    target: Function | string;
+    /**
+     * Property of the object to be validated.
+     */
+    propertyName: string;
+    /**
+     * Constraint class that performs validation. Used only for custom validations.
+     */
+    constraintCls?: Function;
+    /**
+     * Array of constraints of this validation.
+     */
+    constraints?: any[];
+    /**
+     * Validation message to be shown in the case of error.
+     */
+    message?: string | ((args: ValidationArguments) => string);
+    /**
+     * Validation groups used for this validation.
+     */
+    groups?: string[];
+    /**
+     * Indicates if validation must be performed always, no matter of validation groups used.
+     */
+    always?: boolean;
+    /**
+     * Specifies if validated value is an array and each of its item must be validated.
+     */
+    each?: boolean;
+    context?: any;
+    /**
+     * Extra options specific to validation type.
+     */
+    validationTypeOptions: any;
+    constructor(args: ValidationMetadataArgs);
+}

package/dist/validator/metadata/ValidationMetadataArgs.d.ts

@@ -0,0 +1,38 @@
+import { ValidationOptions } from '../decorator/ValidationOptions';
+/**
+ * Constructor arguments for ValidationMetadata class.
+ */
+export interface ValidationMetadataArgs {
+    /**
+     * Validation type.
+     */
+    type: string;
+    /**
+     * Validator name.
+     */
+    name?: string;
+    /**
+     * Object that is used to be validated.
+     */
+    target: Function | string;
+    /**
+     * Property of the object to be validated.
+     */
+    propertyName: string;
+    /**
+     * Constraint class that performs validation. Used only for custom validations.
+     */
+    constraintCls?: Function;
+    /**
+     * Array of constraints of this validation.
+     */
+    constraints?: any[];
+    /**
+     * Validation options.
+     */
+    validationOptions?: ValidationOptions;
+    /**
+     * Extra options specific to validation type.
+     */
+    validationTypeOptions?: any;
+}

package/dist/validator/register-decorator.d.ts

@@ -0,0 +1,36 @@
+import { ValidatorConstraintInterface } from './validation/ValidatorConstraintInterface';
+import { ValidationOptions } from './decorator/ValidationOptions';
+export interface ValidationDecoratorOptions {
+    /**
+     * Target object to be validated.
+     */
+    target: Function;
+    /**
+     * Target object's property name to be validated.
+     */
+    propertyName: string;
+    /**
+     * Name of the validation that is being registered.
+     */
+    name?: string;
+    /**
+     * Indicates if this decorator will perform async validation.
+     */
+    async?: boolean;
+    /**
+     * Validator options.
+     */
+    options?: ValidationOptions;
+    /**
+     * Array of validation constraints.
+     */
+    constraints?: any[];
+    /**
+     * Validator that performs validation.
+     */
+    validator: ValidatorConstraintInterface | Function;
+}
+/**
+ * Registers a custom validation decorator.
+ */
+export declare function registerDecorator(options: ValidationDecoratorOptions): void;

package/dist/validator/utils/convert-to-array.util.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Convert Map, Set to Array
+ */
+export declare function convertToArray<T>(val: Array<T> | Set<T> | Map<any, T>): Array<T>;

package/dist/validator/utils/get-global.util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This function returns the global object across Node and browsers.
+ *
+ * Note: `globalThis` is the standardized approach however it has been added to
+ * Node.js in version 12. We need to include this snippet until Node 12 EOL.
+ */
+export declare function getGlobal(): typeof globalThis;

package/dist/validator/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './convert-to-array.util';
+export * from './get-global.util';
+export * from './is-promise.util';

package/dist/validator/utils/is-promise.util.d.ts

@@ -0,0 +1 @@
+export declare function isPromise<T = any>(p: any): p is Promise<T>;

package/dist/validator/validation/ValidationArguments.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Arguments being sent to message builders - user can create message either by simply returning a string,
+ * either by returning a function that accepts MessageArguments and returns a message string built based on these arguments.
+ */
+export interface ValidationArguments {
+    /**
+     * Validating value.
+     */
+    value: any;
+    /**
+     * Constraints set by this validation type.
+     */
+    constraints: any[];
+    /**
+     * Name of the target that is being validated.
+     */
+    targetName: string;
+    /**
+     * Object that is being validated.
+     */
+    object: object;
+    /**
+     * Name of the object's property being validated.
+     */
+    property: string;
+}

package/dist/validator/validation/ValidationError.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Validation error description.
+ */
+export declare class ValidationError {
+    /**
+     * Object that was validated.
+     *
+     * OPTIONAL - configurable via the ValidatorOptions.validationError.target option
+     */
+    target?: object;
+    /**
+     * Object's property that haven't pass validation.
+     */
+    property: string;
+    /**
+     * Value that haven't pass a validation.
+     *
+     * OPTIONAL - configurable via the ValidatorOptions.validationError.value option
+     */
+    value?: any;
+    /**
+     * Constraints that failed validation with error messages.
+     */
+    constraints?: {
+        [type: string]: string;
+    };
+    /**
+     * Contains all nested validation errors of the property.
+     */
+    children?: ValidationError[];
+    contexts?: {
+        [type: string]: any;
+    };
+    /**
+     *
+     * @param shouldDecorate decorate the message with ANSI formatter escape codes for better readability
+     * @param hasParent true when the error is a child of an another one
+     * @param parentPath path as string to the parent of this property
+     * @param showConstraintMessages show constraint messages instead of constraint names
+     */
+    toString(shouldDecorate?: boolean, hasParent?: boolean, parentPath?: string, showConstraintMessages?: boolean): string;
+}

package/dist/validator/validation/ValidationExecutor.d.ts

@@ -0,0 +1,28 @@
+import { Validator } from './Validator';
+import { ValidationError } from './ValidationError';
+import { ValidationMetadata } from '../metadata/ValidationMetadata';
+import { ValidatorOptions } from './ValidatorOptions';
+/**
+ * Executes validation over given object.
+ */
+export declare class ValidationExecutor {
+    private validator;
+    private validatorOptions?;
+    awaitingPromises: Promise<any>[];
+    ignoreAsyncValidations: boolean;
+    private metadataStorage;
+    constructor(validator: Validator, validatorOptions?: ValidatorOptions);
+    execute(object: object, targetSchema: string, validationErrors: ValidationError[]): void;
+    whitelist(object: any, groupedMetadatas: {
+        [propertyName: string]: ValidationMetadata[];
+    }, validationErrors: ValidationError[]): void;
+    stripEmptyErrors(errors: ValidationError[]): ValidationError[];
+    private performValidations;
+    private generateValidationError;
+    private conditionalValidations;
+    private customValidations;
+    private nestedValidations;
+    private mapContexts;
+    private createValidationError;
+    private getConstraintType;
+}

package/dist/validator/validation/ValidationTypes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Validation types.
+ */
+export declare class ValidationTypes {
+    static CUSTOM_VALIDATION: string;
+    static NESTED_VALIDATION: string;
+    static PROMISE_VALIDATION: string;
+    static CONDITIONAL_VALIDATION: string;
+    static WHITELIST: string;
+    static IS_DEFINED: string;
+    /**
+     * Checks if validation type is valid.
+     */
+    static isValid(type: string): boolean;
+}

package/dist/validator/validation/ValidationUtils.d.ts

@@ -0,0 +1,8 @@
+import { ValidationArguments } from './ValidationArguments';
+/**
+ * Convert the constraint to a string to be shown in an error
+ */
+export declare function constraintToString(constraint: unknown): string;
+export declare class ValidationUtils {
+    static replaceMessageSpecialTokens(message: string | ((args: ValidationArguments) => string), validationArguments: ValidationArguments): string;
+}