@nu-art/ts-common 0.203.44 → 0.203.46

package/core/exceptions/http-codes.d.ts

@@ -123,6 +123,9 @@ export declare const HttpCodes: {
         readonly ENTITY_IS_OUTDATED: ((userMessage: string, debugMessage?: string, cause?: Error) => ApiException<ApiError_GeneralErrorMessage>) & {
             code: number;
         };
+        readonly INTERNAL_MISMATCH: ((userMessage: string, debugMessage?: string, cause?: Error) => ApiException<ApiError_GeneralErrorMessage>) & {
+            code: number;
+        };
         readonly OPERATION_FAILED: ((userMessage: string, debugMessage?: string, cause?: Error) => ApiException<ApiError_GeneralErrorMessage>) & {
             code: number;
         };

package/core/exceptions/http-codes.js

@@ -71,6 +71,7 @@ exports.HttpCodes = {
         //custom
         ENTITY_ALREADY_EXISTS: createGeneralError(460),
         ENTITY_IS_OUTDATED: createGeneralError(461),
+        INTERNAL_MISMATCH: createGeneralError(462),
         OPERATION_FAILED: createGeneralError(490),
     },
     _5XX: {

package/core/exceptions/types.d.ts

@@ -1,4 +1,4 @@
-export type ResponseError<K extends string = string, Data extends any = any> = {
+export type ResponseError<K extends string = string, Data = any> = {
     type: K;
     data: Data;
 };

package/core/module-manager.d.ts

@@ -5,23 +5,23 @@ import { Module } from './module';
 import { Logger } from './logger/Logger';
 export declare function moduleResolver(): Module<any, any, import("..").Validator<any> | import("..").TypeValidator<any>>[];
 export declare const RuntimeModules: () => {
-    filter: <T extends unknown>(filter: (item: T, index: number, array: T[]) => boolean) => T[];
-    find: <T_1 extends unknown>(filter: (item: T_1, index: number, array: T_1[]) => boolean) => T_1;
-    some: <T_2 extends unknown>(filter: (item: T_2, index: number, array: T_2[]) => boolean) => T_2;
-    map: <T_3 extends unknown, S extends unknown>(processor: (item: T_3, index: number, array: T_3[]) => S) => S[];
-    forEach: <T_4 extends unknown>(processor: (item: T_4, index: number, array: T_4[]) => void) => void;
-    includes: <T_5 extends unknown>(module: T_5) => boolean;
+    filter: <T>(filter: (item: T, index: number, array: T[]) => boolean) => T[];
+    find: <T_1>(filter: (item: T_1, index: number, array: T_1[]) => boolean) => T_1;
+    some: <T_2>(filter: (item: T_2, index: number, array: T_2[]) => boolean) => T_2;
+    map: <T_3, S>(processor: (item: T_3, index: number, array: T_3[]) => S) => S[];
+    forEach: <T_4>(processor: (item: T_4, index: number, array: T_4[]) => void) => void;
+    includes: <T_5>(module: T_5) => boolean;
     all: Module<any, any, import("..").Validator<any> | import("..").TypeValidator<any>>[];
 };
 export declare class ModuleManager extends Logger {
     protected config: any;
     readonly modules: {
-        filter: <T extends unknown>(filter: (item: T, index: number, array: T[]) => boolean) => T[];
-        find: <T_1 extends unknown>(filter: (item: T_1, index: number, array: T_1[]) => boolean) => T_1;
-        some: <T_2 extends unknown>(filter: (item: T_2, index: number, array: T_2[]) => boolean) => T_2;
-        map: <T_3 extends unknown, S extends unknown>(processor: (item: T_3, index: number, array: T_3[]) => S) => S[];
-        forEach: <T_4 extends unknown>(processor: (item: T_4, index: number, array: T_4[]) => void) => void;
-        includes: <T_5 extends unknown>(module: T_5) => boolean;
+        filter: <T>(filter: (item: T, index: number, array: T[]) => boolean) => T[];
+        find: <T_1>(filter: (item: T_1, index: number, array: T_1[]) => boolean) => T_1;
+        some: <T_2>(filter: (item: T_2, index: number, array: T_2[]) => boolean) => T_2;
+        map: <T_3, S>(processor: (item: T_3, index: number, array: T_3[]) => S) => S[];
+        forEach: <T_4>(processor: (item: T_4, index: number, array: T_4[]) => void) => void;
+        includes: <T_5>(module: T_5) => boolean;
         all: Module<any, any, import("..").Validator<any> | import("..").TypeValidator<any>>[];
     };
     static instance: ModuleManager;

package/db/dependencies-test.d.ts

@@ -0,0 +1,5 @@
+type NonEmptyObject<T> = T extends object ? (keyof T extends never ? never : T) : never;
+export type DotNotation<T extends object> = NonNullable<T extends object ? {
+    [K in keyof T]: K extends string ? T[K] extends object ? NonEmptyObject<T[K]> extends never ? T[K] extends string | string[] ? `${K & string}` : never : `${K & string}.${DotNotation<T[K]>}` : `${K & string}` : never;
+}[keyof T] : ''>;
+export {};

package/db/dependencies-test.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const pah = {
+    'a.yId': { dbName: 'y' }
+};

package/db/types.d.ts

@@ -1,4 +1,4 @@
-import { DB_Object, OmitDBObject, SubsetKeys, SubsetObjectByKeys, UniqueId } from '../utils/types';
+import { DB_Object, DotNotation, DotNotationValueType, OmitDBObject, SubsetObjectByKeys, UniqueId } from '../utils/types';
 import { ValidatorTypeResolver } from '../validator/validator-core';
 export type DBIndex<T extends DB_Object> = {
     id: string;
@@ -18,9 +18,8 @@ export type VersionsDeclaration<Versions extends VersionType[] = ['1.0.0'], Type
     versions: Versions;
     types: Types;
 };
-export type InnerDependencies<T extends DB_Object, K extends SubsetKeys<keyof T, T, string | string[]>, Proto extends DBProto<any>> = {
-    key: K;
-    proto: Proto;
+export type ProtoDependencies<T extends object> = {
+    [K in DotNotation<T>]?: DBProto<any>;
 };
 type Exact<T, Shape> = T & {
     [K in Exclude<keyof Shape, keyof T>]?: never;
@@ -35,14 +34,20 @@ type Exact<T, Shape> = T & {
  * @template Dependencies (Future Use) Defines dependencies or relationships to other database objects.
  */
 export type Proto_DB_Object<T extends DB_Object, DatabaseName extends string, GeneratedKeys extends keyof T | never, Versions extends VersionsDeclaration<VersionType[]>, UniqueKeys extends keyof T = Default_UniqueKey, Dependencies extends Exact<{
-    [K in SubsetKeys<keyof T, T, string | string[]>]?: DBProto<any>;
+    [K in DotNotation<T>]?: DBProto<any>;
 }, Dependencies> = never> = {
     type: T;
     dbName: DatabaseName;
     generatedKeys: GeneratedKeys | keyof DB_Object;
     versions: Versions;
     uniqueKeys: UniqueKeys;
-    dependencies: Dependencies;
+    dependencies: keyof Dependencies extends never ? never : Dependencies;
+};
+type DependenciesImpl<T extends object, D extends ProtoDependencies<T>> = {
+    [K in keyof D]: D[K] extends DBProto<any> ? {
+        dbName: D[K]['dbName'];
+        fieldType: TypeOfTypeAsString<DotNotationValueType<T, K & string>>;
+    } : never;
 };
 /**
  * Extends Proto_DB_Object with additional UI and validation details.
@@ -52,6 +57,7 @@ export type Proto_DB_Object<T extends DB_Object, DatabaseName extends string, Ge
  * @template GeneratedSubType The subset of P's type that is auto-generated.
  */
 export type DBProto<P extends Proto_DB_Object<any, string, any, VersionsDeclaration<VersionType[]>, any, any>, ModifiableSubType = Omit<P['type'], P['generatedKeys'] | keyof DB_Object>, GeneratedSubType = SubsetObjectByKeys<P['type'], P['generatedKeys']>> = {
+    proto: P;
     uiType: ModifiableSubType & Partial<GeneratedSubType> & Partial<DB_Object>;
     preDbType: ModifiableSubType & Partial<GeneratedSubType>;
     dbType: P['type'];
@@ -67,6 +73,7 @@ export type DBProto<P extends Proto_DB_Object<any, string, any, VersionsDeclarat
     };
     metadata?: Metadata<OmitDBObject<P['type']>>;
     lockKeys?: (keyof P['type'])[];
+    dependencies: DependenciesImpl<P['type'], P['dependencies']>;
 };
 /**
  * Represents the definition of a database entity with metadata and validation rules.
@@ -86,6 +93,7 @@ export type DBDef_V3<Proto extends DBProto<any, any, any>> = {
     indices?: Proto['indices'];
     lockKeys?: Proto['lockKeys'];
     metadata?: Proto['metadata'];
+    dependencies?: Proto['dependencies'];
 };
 /**
  * @field version - First item in the array is current version, Must pass all past versions with the current, default version is 1.0.0
@@ -107,21 +115,26 @@ export type DBDef<T extends DB_Object, Ks extends keyof T = Default_UniqueKey> =
     TTL?: number;
     lastUpdatedTTL?: number;
 };
-type TypeOf<ValueType> = ValueType extends any[] ? 'array' : ValueType extends object ? 'object' : ValueType extends string ? 'string' : ValueType extends number ? 'number' : ValueType extends boolean ? 'boolean' : never;
+export type test = TypeOfTypeAsString<DotNotationValueType<{
+    a?: {
+        b?: string;
+    };
+}, 'a.b'>>;
+export type TypeOfTypeAsString<ValueType> = ValueType extends any[] ? ValueType extends string[] ? 'string[]' : ValueType extends number[] ? 'number[]' : ValueType extends boolean[] ? 'boolean[]' : ValueType extends object[] ? 'object[]' : 'array' : ValueType extends string ? 'string' : ValueType extends number ? 'number' : ValueType extends boolean ? 'boolean' : ValueType extends object ? 'object' : never;
 export type MetadataProperty<ValueType> = {
-    valueType: TypeOf<ValueType>;
+    valueType: TypeOfTypeAsString<ValueType>;
     optional: boolean;
     description: string;
 };
-export type MetadataObject<T extends any> = {
+export type MetadataObject<T> = {
     [K in keyof T]-?: MetadataNested<T[K]>;
 };
-export type MetadataNested<T extends any> = T extends (infer I)[] ? MetadataProperty<T> & {
+export type MetadataNested<T> = T extends (infer I)[] ? MetadataProperty<T> & {
     metadata: Metadata<I>;
 } : T extends object ? MetadataProperty<T> & {
     metadata: MetadataObject<T>;
 } : MetadataProperty<T>;
-export type Metadata<T extends any> = T extends (infer I)[] ? MetadataProperty<T> & {
+export type Metadata<T> = T extends (infer I)[] ? MetadataProperty<T> & {
     metadata: Metadata<I>;
 } : T extends object ? MetadataObject<T> : MetadataProperty<T>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/ts-common",
-  "version": "0.203.44",
+  "version": "0.203.46",
   "description": "js and ts infra",
   "keywords": [
     "TacB0sS",

package/tools/Replacer.js

@@ -53,10 +53,9 @@ class Replacer extends Logger_1.Logger {
     replaceParams(content = '', runtime) {
         const matches = content.match(Replacer.Regexp_paramGroup);
         return (matches === null || matches === void 0 ? void 0 : matches.reduce((toRet, match) => {
-            var _a;
             let param = match;
             while (Replacer.Regexp_param.test(param))
-                param = (_a = param.match(Replacer.Regexp_param)) === null || _a === void 0 ? void 0 : _a[1];
+                param = param.match(Replacer.Regexp_param)[1];
             if (param === undefined)
                 return toRet;
             const value = this.resolveParam(param, toRet, runtime);

package/utils/array-tools.d.ts

@@ -74,7 +74,7 @@ export declare function sortArray<T>(array: T[], map?: keyof T | (keyof T)[] | (
 /**
  * "splits" array into given size of chunks and then does "action" on chunk and return to array of actions on chunks +-
  * */
-export declare function batchAction<T extends any = any, R extends any = any>(arr: T[], chunk: number, action: (elements: T[]) => Promise<R | R[]>): Promise<R[]>;
+export declare function batchAction<T = any, R = any>(arr: T[], chunk: number, action: (elements: T[]) => Promise<R | R[]>): Promise<R[]>;
 /**
  * Processes an array of promise-returning tasks sequentially.
  *
@@ -94,7 +94,7 @@ export declare function batchAction<T extends any = any, R extends any = any>(ar
  * @param promises
  */
 export declare function Promise_all_sequentially<T>(promises: Array<() => Promise<T>>): Promise<T[]>;
-export declare function batchActionParallel<T extends any = any, R extends any = any>(arr: T[], chunk: number, action: (elements: T[]) => Promise<R | R[]>): Promise<R[]>;
+export declare function batchActionParallel<T = any, R = any>(arr: T[], chunk: number, action: (elements: T[]) => Promise<R | R[]>): Promise<R[]>;
 /**
  * Returns a flat array from an array of arrays.
  * @param arr An array that is potentially a matrix
@@ -102,21 +102,21 @@ export declare function batchActionParallel<T extends any = any, R extends any =
  */
 export declare function flatArray<T extends any[], K = NestedArrayType<T>>(arr: T, result?: K[]): K[];
 export declare function filterFlatInstances<T extends any[], K = NestedArrayType<T>>(arr: T, result?: K[]): Exclude<K, undefined>[];
-export declare function groupArrayBy<T extends any, K extends string | number>(arr: T[], mapper: (item: T, index: number) => K): {
+export declare function groupArrayBy<T, K extends string | number>(arr: T[], mapper: (item: T, index: number) => K): {
     key: K;
     values: T[];
 }[];
-export declare function toggleInArray<T extends any = string, K extends any = (T extends object ? keyof T : T)>(arr: T[], item: T, mapper?: (item: T) => K): void;
-export declare function generateArray<T extends any = number>(length: number, mapper?: (index: number) => T): T[];
-export declare function asArray<T extends any>(toBeArray: T | T[]): T[];
-export declare function asOptionalArray<T extends any>(toBeArray?: T | T[]): T[] | undefined;
-export declare function lastElement<T extends any>(array: T[] | undefined): T | undefined;
-export declare function firstElement<T extends any>(array?: T[]): T | undefined;
-export declare function arrayIncludesAny<T extends any>(arr1: T[], arr2: T[]): boolean;
+export declare function toggleInArray<T = string, K = (T extends object ? keyof T : T)>(arr: T[], item: T, mapper?: (item: T) => K): void;
+export declare function generateArray<T = number>(length: number, mapper?: (index: number) => T): T[];
+export declare function asArray<T>(toBeArray: T | T[]): T[];
+export declare function asOptionalArray<T>(toBeArray?: T | T[]): T[] | undefined;
+export declare function lastElement<T>(array: T[] | undefined): T | undefined;
+export declare function firstElement<T>(array?: T[]): T | undefined;
+export declare function arrayIncludesAny<T>(arr1: T[], arr2: T[]): boolean;
 /**
  * Returns true if arr1 returns the entirety of arr2
  * @param arr1
  * @param arr2
  */
-export declare function arrayIncludesAll<T extends any>(arr1: T[], arr2: T[]): boolean;
+export declare function arrayIncludesAll<T>(arr1: T[], arr2: T[]): boolean;
 export {};

package/utils/object-tools.d.ts

@@ -7,10 +7,10 @@ export declare function _values<T extends TS_Object = TS_Object>(object: T): (T[
 export declare function _setTypedProp<T extends TS_Object>(instance: T, key: keyof T, value: T[keyof T]): void;
 export declare function cloneArr<T>(value: T[]): T[];
 export declare function cloneObj<T extends TS_Object>(obj: T): T;
-export declare function partialCompare<T extends any>(one?: T, two?: T, keysToFilterOut?: (keyof T)[]): boolean;
+export declare function partialCompare<T>(one?: T, two?: T, keysToFilterOut?: (keyof T)[]): boolean;
 /**
  * Returns true for equal.
  */
-export declare function compare<T extends any>(one?: T, two?: T, keys?: (keyof T)[]): boolean;
+export declare function compare<T>(one?: T, two?: T, keys?: (keyof T)[]): boolean;
 export declare function assert<T>(message: string, expected: T, actual: T): void;
 export declare function filterKeys<T extends TS_Object = TS_Object>(obj: T, keys?: keyof T | (keyof T)[], filter?: (k: keyof T, obj: T) => boolean): T;

package/utils/tools.d.ts

@@ -10,10 +10,10 @@ export declare const EmptyArray: readonly never[];
 export declare const voidFunction: () => Promise<void>;
 export declare const functionThatReturnsFalse: () => false;
 export declare const functionThatReturnsTrue: () => true;
-export declare const resolveContent: <T extends unknown = any, P extends any[] = any[]>(content: ResolvableContent<T, P>, ...param: P) => T;
-export declare const resolveFunctionOrValue: <T extends unknown = any, P extends any[] = any[]>(content: ResolvableContent<T, P>, ...param: P) => T;
-export declare function exists<T extends any = any>(item: T | undefined | null): item is T;
-export declare function freeze<T extends any = any>(item: T): Readonly<T>;
+export declare const resolveContent: <T = any, P extends any[] = any[]>(content: ResolvableContent<T, P>, ...param: P) => T;
+export declare const resolveFunctionOrValue: <T = any, P extends any[] = any[]>(content: ResolvableContent<T, P>, ...param: P) => T;
+export declare function exists<T = any>(item: T | undefined | null): item is T;
+export declare function freeze<T = any>(item: T): Readonly<T>;
 export declare const logicalXOR: (a: boolean, b: boolean) => boolean;
 export type KeyBinder<K extends string, Type> = {
     Key: K;

package/utils/tools.js

@@ -66,7 +66,9 @@ exports.voidFunction = Object.freeze(() => __awaiter(void 0, void 0, void 0, fun
 }));
 exports.functionThatReturnsFalse = Object.freeze(() => false);
 exports.functionThatReturnsTrue = Object.freeze(() => true);
-const resolveContent = (content, ...param) => typeof content === 'function' ? content(...param) : content;
+const resolveContent = (content, ...param) => {
+    return typeof content === 'function' ? content(...param) : content;
+};
 exports.resolveContent = resolveContent;
 exports.resolveFunctionOrValue = exports.resolveContent;
 function exists(item) {

package/utils/types.d.ts

@@ -52,7 +52,7 @@ export type SubsetObjectByValue<T, ExpectedType> = SubsetObjectByKeys<T, SubsetK
 export type OptionalKeys<T extends TS_Object> = Exclude<{
     [K in keyof T]: T extends Record<K, T[K]> ? never : K;
 }[keyof T], undefined>;
-export type MandatoryKeys<T extends TS_Object, V extends any = any> = Exclude<{
+export type MandatoryKeys<T extends TS_Object, V = any> = Exclude<{
     [K in keyof T]: T extends Record<K, T[K]> ? (T[K] extends V ? K : never) : never;
 }[keyof T], undefined>;
 export type RequireOptionals<T extends TS_Object, Keys extends OptionalKeys<T> = OptionalKeys<T>> = Pick<T, Exclude<keyof T, Keys>> & {
@@ -68,7 +68,7 @@ export type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<
     [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
 }[Keys];
 export type Constructor<T> = new (...args: any) => T;
-export type ArrayType<T extends any> = T extends (infer I)[] ? I : never;
+export type ArrayType<T> = T extends (infer I)[] ? I : never;
 export type NestedArrayType<T extends any[]> = T extends (infer I)[] ? I extends any[] ? NestedArrayType<I> : I : never;
 export type PartialProperties<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type KeyValue = TypedKeyValue<string, string>;
@@ -185,9 +185,10 @@ export type RecursiveWritable<T> = T extends ReadonlyArray<infer R> ? RecursiveW
  * type Profile = { name: string; contacts: { email: { primary: string; secondary: string } } };
  * type ProfilePaths = DotNotation<Profile>; // 'name' | 'contacts' | 'contacts.email' | 'contacts.email.primary' | 'contacts.email.secondary'
  */
-export type DotNotation<T> = T extends object ? {
-    [K in keyof T]: K extends string ? T[K] extends object ? `${K & string}` | `${K & string}.${DotNotation<T[K]>}` : `${K & string}` : never;
-}[keyof T] : '';
+type NonEmptyObject<T> = T extends object ? (keyof T extends never ? never : T) : never;
+export type DotNotation<T extends object> = NonNullable<T extends object ? {
+    [K in keyof T]: K extends string ? T[K] extends object ? NonEmptyObject<T[K]> extends never ? T[K] extends string | string[] ? `${K & string}` : never : `${K & string}.${DotNotation<T[K]>}` : `${K & string}` : never;
+}[keyof T] : ''>;
 /**
  * Replaces the type of nested property within an object, based on a specified path.
  *
@@ -213,11 +214,12 @@ export type DotNotation<T> = T extends object ? {
  * type NewProfile = ManipulateInnerPropValue<Profile, 'contacts.email.primary', boolean>;
  * // Result: { name: string; contacts: { email: { primary: boolean; secondary: string } } }
  */
-export type ManipulateInnerPropValue<ObjectType, PropertyPath extends DotNotation<ObjectType>, NewValueType> = PropertyPath extends `${infer Key}.${infer Rest}` ? Key extends keyof ObjectType ? {
-    [Prop in keyof ObjectType]: Prop extends Key ? Rest extends DotNotation<ObjectType[Key]> ? ManipulateInnerPropValue<ObjectType[Key], Rest, NewValueType> : never : ObjectType[Prop];
+export type ManipulateInnerPropValue<ObjectType extends object, PropertyPath extends DotNotation<ObjectType>, NewValueType> = PropertyPath extends `${infer Key}.${infer Rest}` ? Key extends keyof ObjectType ? {
+    [Prop in keyof ObjectType]: Prop extends Key ? ObjectType[Key] extends object ? Rest extends DotNotation<ObjectType[Key]> ? ManipulateInnerPropValue<ObjectType[Key], Rest, NewValueType> : never : ObjectType[Prop] : never;
 } : never : {
     [Prop in keyof ObjectType]: Prop extends PropertyPath ? NewValueType : ObjectType[Prop];
 };
+export type DotNotationValueType<ObjectType extends object, Path extends string> = Path extends `${infer First}.${infer Rest}` ? First extends keyof ObjectType ? NonNullable<ObjectType[First]> extends object ? DotNotationValueType<NonNullable<ObjectType[First]>, Rest> : never : never : Path extends keyof ObjectType ? NonNullable<ObjectType[Path]> : never;
 export type Exact<T> = {
     [K in keyof T]: T[K];
 } & {
@@ -232,3 +234,4 @@ export type Exact<T> = {
 export type WithRequired<T, K extends keyof T> = T & {
     [P in K]-?: T[P];
 };
+export {};

package/validator/type-validators.d.ts

@@ -1,29 +1,29 @@
 import { InvalidResult, InvalidResultObject, Validator, ValidatorTypeResolver } from './validator-core';
 import { ArrayType, AuditBy, RangeTimestamp, TypedMap } from '../utils/types';
 export declare const tsValidateDynamicObject: <T extends object>(valuesValidator: ValidatorTypeResolver<T[keyof T]>, keysValidator: ValidatorTypeResolver<string>, mandatory?: boolean) => (import("./validator-core").ValidatorImpl<any> | ((input?: T | undefined) => InvalidResultObject<T> | undefined))[];
-export declare const tsValidateUnion: <T extends unknown>(validators: ValidatorTypeResolver<T>[], mandatory?: boolean) => import("./validator-core").ValidatorImpl<any>[];
-export declare const tsValidateCustom: <T extends unknown>(processor: (input?: T | undefined, parentInput?: any) => InvalidResult<T>, mandatory?: boolean) => Validator<T>[];
+export declare const tsValidateUnion: <T>(validators: ValidatorTypeResolver<T>[], mandatory?: boolean) => import("./validator-core").ValidatorImpl<any>[];
+export declare const tsValidateCustom: <T>(processor: (input?: T | undefined, parentInput?: any) => InvalidResult<T>, mandatory?: boolean) => Validator<T>[];
 declare const typeFunc: (type: any) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
 type types = ReturnType<typeof typeFunc>;
 type validatorObject<T> = {
     [k in types]?: ValidatorTypeResolver<T>;
 };
-export declare const tsValidateUnionV3: <T extends unknown>(validatorObject: validatorObject<T>, mandatory?: boolean) => ((input?: T | undefined) => any)[];
+export declare const tsValidateUnionV3: <T>(validatorObject: validatorObject<T>, mandatory?: boolean) => (import("./validator-core").ValidatorImpl<any> | ((input?: T | undefined) => "Input does not match any of the possible types" | InvalidResult<T> | undefined))[];
 export declare const tsValidateArray: <T extends any[], I extends ArrayType<T> = ArrayType<T>>(validator: ValidatorTypeResolver<I> | ValidatorTypeResolver<I>[], mandatory?: boolean, minimumLength?: number) => Validator<I[]>;
 export declare const tsValidateString: (length?: number | [number, number], mandatory?: boolean) => Validator<string>;
 export declare const tsValidateStringMinLength: (length: number, mandatory?: boolean) => Validator<string>;
 export declare const tsValidateNumber: (mandatory?: boolean) => Validator<number>;
 export declare const tsValidateEnum: (enumType: TypedMap<number | string>, mandatory?: boolean) => Validator<number | string>;
 export declare const tsValidateBoolean: (mandatory?: boolean) => Validator<boolean>;
-export declare const tsValidateValue: <T>(values: T[], mandatory?: boolean) => Validator<any>;
+export declare const tsValidateValue: <T>(values: readonly T[] | T[], mandatory?: boolean) => Validator<any>;
 export declare const tsValidateIsInRange: (ranges: [number, number][], mandatory?: boolean) => Validator<number>;
 export declare const tsValidateRange: (mandatory?: boolean) => Validator<[number, number] | undefined>;
 export declare const tsValidateRegexp: (regexp: RegExp, mandatory?: boolean) => Validator<string>;
 export declare const tsValidateTimestamp: (interval?: number, mandatory?: boolean) => Validator<number>;
-export declare const tsValidateAudit: (range?: RangeTimestamp) => (audit?: AuditBy) => any;
-export declare const tsValidateNonMandatoryObject: <T extends object>(validator: ValidatorTypeResolver<T>) => ((input?: T | undefined) => any)[];
-export declare const tsValidateOptionalObject: <T extends object>(validator: ValidatorTypeResolver<T>) => ((input?: T | undefined) => any)[];
-export declare const tsValidator_valueByKey: <T extends unknown>(validatorObject: {
+export declare const tsValidateAudit: (range?: RangeTimestamp) => (audit?: AuditBy) => string | undefined;
+export declare const tsValidateNonMandatoryObject: <T extends object | undefined>(validator: ValidatorTypeResolver<T>) => (import("./validator-core").ValidatorImpl<any> | ((input?: T | undefined) => InvalidResult<T> | undefined))[];
+export declare const tsValidateOptionalObject: <T extends object | undefined>(validator: ValidatorTypeResolver<T>) => (import("./validator-core").ValidatorImpl<any> | ((input?: T | undefined) => InvalidResult<T> | undefined))[];
+export declare const tsValidator_valueByKey: <T>(validatorObject: {
     [k: string]: Validator<any> | import("./validator-core").TypeValidator<any>;
 }, prop?: string) => ValidatorTypeResolver<T>;
 export declare const tsValidator_ArrayOfObjectsByKey: <T extends Object>(key: keyof T, validatorMap: {

package/validator/validator-core.d.ts

@@ -8,24 +8,23 @@ import { CustomException } from '../core/exceptions/exceptions';
  * 			K extends [infer E1, infer E2, infer E3] ? [Validator<E1>,Validator<E2>,Validator<E2>] :
  * 				K extends [infer E1, infer E2, infer E3, infer E4] ? [Validator<E1>,Validator<E2>,Validator<E2>,Validator<E4>] :
  */
-export type ValidatorTypeResolver<K> = K extends [infer E1] ? Validator<K> : K extends [infer E1, infer E2] ? Validator<K> : K extends [infer E1, infer E2, infer E3] ? Validator<K> : K extends [infer E1, infer E2, infer E3, infer E4] ? Validator<K> : K extends any[] ? Validator<K> : K extends TS_Object ? TypeValidator<K> | Validator<K> : Validator<K>;
-export type ValidatorImpl<P> = (p?: P) => (InvalidResult<P> | undefined);
+export type ValidatorTypeResolver<K> = K extends [any] ? Validator<K> : K extends [any, any] ? Validator<K> : K extends [any, any, any] ? Validator<K> : K extends [any, any, any, any] ? Validator<K> : K extends any[] ? Validator<K> : K extends TS_Object ? TypeValidator<K> | Validator<K> : Validator<K>;
+export type ValidatorImpl<P> = (p?: P, parentObj?: any) => (InvalidResult<P> | undefined);
 export type Validator<P> = ValidatorImpl<P> | ValidatorImpl<P>[];
 export type TypeValidator<T extends TS_Object> = {
     [P in keyof T]-?: ValidatorTypeResolver<T[P]>;
 };
-export type InvalidResultObject<T extends any> = {
+export type InvalidResultObject<T> = {
     [K in keyof T]?: InvalidResult<T[K]>;
 };
-export type InvalidResultArray<T extends any> = InvalidResult<T> | undefined;
-export type InvalidResult<T extends any> = T extends object ? InvalidResultObject<T> | string : T extends (infer I)[] ? (InvalidResultArray<I>[]) | string : string;
-export declare class ValidationException<T extends any> extends CustomException {
+export type InvalidResultArray<T> = InvalidResult<T> | undefined;
+export type InvalidResult<T> = T extends object ? InvalidResultObject<T> | string | undefined : T extends (infer I)[] ? (InvalidResultArray<I>[]) | string | undefined : string | undefined;
+export declare class ValidationException<T> extends CustomException {
     input?: T;
     result?: InvalidResult<T>;
     constructor(debugMessage: string, input?: T, result?: InvalidResult<T>, e?: Error);
 }
-export declare const assertValidateMandatoryProperty: (mandatory: boolean, input?: any) => void;
 export declare const tsValidateExists: (mandatory?: boolean) => ValidatorImpl<any>;
-export declare const tsValidate: <T extends unknown>(instance: T | undefined, _validator: ValidatorTypeResolver<T>, strict?: boolean) => any;
-export declare const tsValidateResult: <T extends unknown>(instance: T | undefined, _validator: ValidatorTypeResolver<T>, key?: keyof T | undefined, parentInstance?: any) => any;
-export declare const tsValidateObject: <T>(__validator: TypeValidator<object>, instance: T, path?: string) => InvalidResultObject<T> | undefined;
+export declare const tsValidate: <T>(instance: T | undefined, _validator: ValidatorTypeResolver<T>, strict?: boolean) => InvalidResult<T> | undefined;
+export declare const tsValidateResult: <T>(instance: T | undefined, _validator: ValidatorTypeResolver<T>, key?: keyof T | undefined, parentInstance?: any) => InvalidResult<T> | undefined;
+export declare const tsValidateObject: <T extends object>(__validator: TypeValidator<T>, instance: T, path?: string) => InvalidResultObject<T> | undefined;

package/validator/validator-core.js

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsValidateObject = exports.tsValidateResult = exports.tsValidate = exports.tsValidateExists = exports.assertValidateMandatoryProperty = exports.ValidationException = void 0;
+exports.tsValidateObject = exports.tsValidateResult = exports.tsValidate = exports.tsValidateExists = exports.ValidationException = void 0;
 const object_tools_1 = require("../utils/object-tools");
 const exceptions_1 = require("../core/exceptions/exceptions");
 class ValidationException extends exceptions_1.CustomException {
@@ -29,9 +29,6 @@ class ValidationException extends exceptions_1.CustomException {
 }
 exports.ValidationException = ValidationException;
 const CONST_NO_ERROR = '###';
-const assertValidateMandatoryProperty = (mandatory, input) => {
-};
-exports.assertValidateMandatoryProperty = assertValidateMandatoryProperty;
 const tsValidateExists = (mandatory = true) => {
     return (input) => {
         if (input !== undefined && input !== null)
@@ -74,7 +71,9 @@ const tsValidateResult = (instance, _validator, key, parentInstance) => {
         return 'No validator provided!';
     const validator = typeof _validator === 'function' ? [_validator] : _validator;
     if (Array.isArray(validator)) {
-        const result = validator.reduce((result, __validator) => result === CONST_NO_ERROR ? result : result || __validator(instance, parentInstance), undefined);
+        const result = validator.reduce((result, __validator) => {
+            return result === CONST_NO_ERROR ? result : result || __validator(instance, parentInstance);
+        }, undefined);
         return result !== CONST_NO_ERROR ? result : undefined;
     }
     if (typeof validator === 'object') {