@nu-art/ts-common 0.203.43 → 0.203.45

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

@@ -113,15 +113,15 @@ export type MetadataProperty<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.43",
+  "version": "0.203.45",
   "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>;

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') {