taon 21.0.63 → 21.0.71

package/browser/fesm2022/taon-browser.mjs

@@ -1,15 +1,15 @@
 import 'reflect-metadata';
-import { _, Utils, Helpers, UtilsOs, config, CoreModels, crossPlatformPath, UtilsTerminal } from 'tnp-core/browser';
+import { _, CoreModels, Utils, Helpers, UtilsOs, config, crossPlatformPath, UtilsTerminal } from 'tnp-core/browser';
 import axios from 'axios';
 import { JSON10 } from 'json10/browser';
 import { walk } from 'lodash-walk-object/browser';
-import { RestResponseWrapper, Resource, Models as Models$1, RestHeaders, Mapping, HttpResponseError } from 'ng2-rest/browser';
+import { RestResponseWrapper, Resource, HttpResponse, RestHeaders, decodeMappingForHeaderJson, DefaultMapping, DefaultModel, HttpResponseError } from 'ng2-rest/browser';
 import { Observable, from, Subject } from 'rxjs';
 import * as i0 from '@angular/core';
 import { InjectionToken, inject as inject$1, PLATFORM_ID, Injectable, ViewContainerRef, ViewChild, Component } from '@angular/core';
-import { Table, OrignalClassKey, Column } from 'taon-typeorm/browser';
+import { Table, Column } from 'taon-typeorm/browser';
 export { AfterInsert, AfterLoad, AfterRecover, AfterRemove, AfterSoftRemove, AfterUpdate, BeforeInsert, BeforeRecover, BeforeRemove, BeforeSoftRemove, BeforeUpdate, Column, Connection, CreateDateColumn, Column as CustomColumn, DeleteDateColumn, Generated, Generated as GeneratedColumn, Index, JoinColumn, JoinTable, ManyToMany, ManyToOne, OneToMany, OneToOne, PrimaryColumn, PrimaryGeneratedColumn, Repository, TreeChildren, TreeParent, UpdateDateColumn, VersionColumn, VirtualColumn } from 'taon-typeorm/browser';
-import { SYMBOL, CLASS } from 'typescript-class-helpers/browser';
+import { CLASS } from 'typescript-class-helpers/browser';
 import * as JSON5 from 'json5';
 import { io } from 'socket.io-client';
 import { isPlatformServer, isPlatformBrowser } from '@angular/common';
@@ -648,9 +648,7 @@ class Realtime {
 var Symbols;
 (function (Symbols) {
     Symbols.ctxInClassOrClassObj = Symbol();
-    Symbols.classNameStaticProperty = SYMBOL.ClassNameStaticProperty;
     Symbols.fullClassNameStaticProperty = `$$fullclassName$$`;
-    Symbols.orignalClass = OrignalClassKey;
     Symbols.orignalClassClonesObj = `$$originalClassClonesObj$$`;
     Symbols.classMethodsNames = `$$classMethodsNames$$`;
     Symbols.REALTIME = new Realtime();
@@ -803,14 +801,14 @@ var ClassHelpers;
             console.error('OBJECT OR CLASS', classFnOrObject);
             throw new Error(`Cannot get name from this object or class.`);
         }
-        return ((classFnOrObject[Symbols.classNameStaticProperty]
-            ? classFnOrObject[Symbols.classNameStaticProperty]
-            : classFnOrObject?.constructor[Symbols.classNameStaticProperty]) ||
+        return ((classFnOrObject[CoreModels.ClassNameStaticProperty]
+            ? classFnOrObject[CoreModels.ClassNameStaticProperty]
+            : classFnOrObject?.constructor[CoreModels.ClassNameStaticProperty]) ||
             (_.isFunction(classFnOrObject) ? CLASS.getName(classFnOrObject) : void 0));
     };
     //#endregion
     ClassHelpers.getOrginalClass = (classFnOrObject) => {
-        const org = classFnOrObject[Symbols.orignalClass];
+        const org = classFnOrObject[CoreModels.OrignalClassKey];
         if (!org) {
             return classFnOrObject;
         }
@@ -832,8 +830,11 @@ var ClassHelpers;
     ClassHelpers.getUniqueKey = (classFnOrObject) => {
         const classFn = _.isFunction(classFnOrObject)
             ? classFnOrObject
-            : classFnOrObject.constructor;
+            : classFnOrObject?.constructor;
         const config = Reflect.getMetadata(Symbols.metadata.options.entity, classFn);
+        if (!config) {
+            return void 0;
+        }
         return config.uniqueKeyProp;
     };
     //#endregion
@@ -857,7 +858,7 @@ var ClassHelpers;
     ClassHelpers.setName = (target, className) => {
         // console.log('setName', className, target.name)
         Validators.classNameVlidation(className, target);
-        target[Symbols.classNameStaticProperty] = className;
+        target[CoreModels.ClassNameStaticProperty] = className;
     };
     //#endregion
     //#region has parent with class name
@@ -1404,7 +1405,7 @@ class RealtimeClient {
      * ...
      */
     listenChangesEntity(entityClassFnOrObj, options) {
-        options = options || {};
+        options = _.cloneDeep(options || {});
         if (_.isObject(entityClassFnOrObj)) {
             const orgObj = entityClassFnOrObj;
             entityClassFnOrObj =
@@ -2695,23 +2696,18 @@ class EndpointContext {
                         // You can override prototype properties or methods here if needed
                         // static properties override allowed
                     }
-                    static { _a = Symbols.orignalClass, _b = Symbols.fullClassNameStaticProperty, _c = Symbols.classNameStaticProperty, _d = Symbols.ctxInClassOrClassObj, _e = Symbols.ctxInClassOrClassObj; }
-                    // @ts-ignore
+                    static { _a = CoreModels.OrignalClassKey, _b = Symbols.fullClassNameStaticProperty, _c = CoreModels.ClassNameStaticProperty, _d = Symbols.ctxInClassOrClassObj, _e = Symbols.ctxInClassOrClassObj; }
                     static { this[_a] = TaonBaseClass; }
-                    // @ts-ignore
                     static { this[_b] = `${ctx.contextName}.${className}`; }
-                    // @ts-ignore
                     static { this[_c] = className; }
                     static { this[_d] = ctx; }
                     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
                     static __getFullPathForClass__(arr = []) {
                         const name = this[Symbols.fullClassNameStaticProperty];
                         arr.push(name);
-                        // @ts-ignore
-                        if (this[Symbols.orignalClass] && // @ts-ignore
-                            this[Symbols.orignalClass].__getFullPathForClass__) {
-                            // @ts-ignore
-                            this[Symbols.orignalClass].__getFullPathForClass__(arr);
+                        if (this[CoreModels.OrignalClassKey] &&
+                            this[CoreModels.OrignalClassKey].__getFullPathForClass__) {
+                            this[CoreModels.OrignalClassKey].__getFullPathForClass__(arr);
                         }
                         return arr.join('/');
                     }
@@ -2761,7 +2757,7 @@ class EndpointContext {
                 //   console.warn(`Please provide className for ${TaonBaseClass.name} class`);
                 // }
                 className = className || key;
-                TaonBaseClass[Symbols.classNameStaticProperty] = className;
+                TaonBaseClass[CoreModels.ClassNameStaticProperty] = className;
                 const clonedClass = this.cloneClassWithNewMetadata({
                     TaonBaseClass,
                     className,
@@ -4126,6 +4122,8 @@ class EndpointContext {
         /* */
         /* */
         /* */
+        /* */
+        /* */
     }
     //#endregion
     //#region methods & getters / middlewares
@@ -4143,7 +4141,7 @@ class EndpointContext {
         middlewares.forEach(middlewareInstanceName => {
             const contextName = this.contextName;
             const interceptorName = `${contextName}-${ClassHelpers.getName(middlewareInstanceName)}`;
-            Resource.request.interceptors.set(interceptorName, {
+            Resource.globalInterceptors.set(interceptorName, {
                 intercept: ({ req, next }) => {
                     const url = new URL(req.url);
                     if (url.pathname.startsWith(`${this.uriPathnameOrNothingIfRoot}/${apiPrefix}/${contextName}/`)) {
@@ -4373,6 +4371,9 @@ class EndpointContext {
             /* */
             /* */
             /* */
+            /* */
+            /* */
+            /* */
         }
         if (!this.isRemoteHost) {
             //#region apply dummy websql express routers
@@ -4598,6 +4599,24 @@ class EndpointContext {
             /* */
             /* */
             /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
         }
         return {
             expressPath: expressPath,
@@ -4659,7 +4678,7 @@ class EndpointContext {
             const middlewareName = ClassHelpers.getName(instance);
             // middlewareName - only needed for inheritace and uniqness of interceptors
             const interceptorKey = `${middlewareName}-${methodConfig.type?.toUpperCase()}-${expressPath}`;
-            Resource.request.methodsInterceptors.set(interceptorKey, {
+            Resource.methodsInterceptors.set(interceptorKey, {
                 intercept: ({ req, next }) => {
                     return instance.interceptClientMethod({
                         req,
@@ -4695,15 +4714,15 @@ class EndpointContext {
                         console.log({ responseData });
                         try {
                             const body = res;
-                            res = new Models$1.HttpResponse({
-                                body: void 0,
-                                isArray: void 0,
-                                method: methodConfig.type,
-                                url: `${ctx.uriOrigin}${'' // TODO express path
-                                }${methodConfig.path} `,
-                            }, Helpers.isBlob(body) || _.isString(body)
+                            const responseStrinOrBlob = Helpers.isBlob(body) || _.isString(body)
                                 ? body
-                                : JSON.stringify(body), RestHeaders.from(headers), void 0, () => body);
+                                : JSON.stringify(body);
+                            res = new HttpResponse(`${ctx.uriOrigin}${'' // TODO express path
+                            }${methodConfig.path} `, methodConfig.type, responseStrinOrBlob, RestHeaders.from(headers), 200, {
+                            // responseMapping: {
+                            //   // entity: ()=>  TODO for electron
+                            // },
+                            }, false);
                             resolve(res);
                         }
                         catch (error) {
@@ -4888,28 +4907,51 @@ class EndpointContext {
                 storage[Symbols.old.ENDPOINT_META_CONFIG][ctx.uriOrigin] = {};
             const endpoints = storage[Symbols.old.ENDPOINT_META_CONFIG];
             let rest;
+            const requestHeaders = RestHeaders.from({});
             if (!endpoints[ctx.uriOrigin][expressPath]) {
-                let headers = {};
                 if (methodConfig.contentType && !methodConfig.responseType) {
-                    rest = Resource.create(ctx.uriOrigin, expressPath, Symbols.old.MAPPING_CONFIG_HEADER, Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                    rest = Resource.create(ctx.uriOrigin, expressPath, {
+                        responseMapping: {
+                            entity: Symbols.old.MAPPING_CONFIG_HEADER,
+                            circular: Symbols.old.CIRCURAL_OBJECTS_MAP_BODY,
+                        },
+                    });
+                    requestHeaders.apply({
                         'Content-Type': methodConfig.contentType,
                         Accept: methodConfig.contentType,
-                    }));
+                    });
                 }
                 else if (methodConfig.contentType && methodConfig.responseType) {
-                    rest = Resource.create(ctx.uriOrigin, expressPath, Symbols.old.MAPPING_CONFIG_HEADER, Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                    rest = Resource.create(ctx.uriOrigin, expressPath, {
+                        responseMapping: {
+                            entity: Symbols.old.MAPPING_CONFIG_HEADER,
+                            circular: Symbols.old.CIRCURAL_OBJECTS_MAP_BODY,
+                        },
+                    });
+                    requestHeaders.apply({
                         'Content-Type': methodConfig.contentType,
                         Accept: methodConfig.contentType,
                         responsetypeaxios: methodConfig.responseType,
-                    }));
+                    });
                 }
                 else if (!methodConfig.contentType && methodConfig.responseType) {
-                    rest = Resource.create(ctx.uriOrigin, expressPath, Symbols.old.MAPPING_CONFIG_HEADER, Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, RestHeaders.from({
+                    rest = Resource.create(ctx.uriOrigin, expressPath, {
+                        responseMapping: {
+                            entity: Symbols.old.MAPPING_CONFIG_HEADER,
+                            circular: Symbols.old.CIRCURAL_OBJECTS_MAP_BODY,
+                        },
+                    });
+                    requestHeaders.apply({
                         responsetypeaxios: methodConfig.responseType,
-                    }));
+                    });
                 }
                 else {
-                    rest = Resource.create(ctx.uriOrigin, expressPath, Symbols.old.MAPPING_CONFIG_HEADER, Symbols.old.CIRCURAL_OBJECTS_MAP_BODY);
+                    rest = Resource.create(ctx.uriOrigin, expressPath, {
+                        responseMapping: {
+                            entity: Symbols.old.MAPPING_CONFIG_HEADER,
+                            circular: Symbols.old.CIRCURAL_OBJECTS_MAP_BODY,
+                        },
+                    });
                 }
                 endpoints[ctx.uriOrigin][expressPath] = rest;
             }
@@ -4937,47 +4979,60 @@ class EndpointContext {
                     /* */
                     throw new Error(errorMessage);
                 }
+                const optionsDecodeHeader = {
+                    useFirstArrayItemClassNameForAllElements: true,
+                };
                 if (currentParam.paramType === 'Path') {
+                    //#region handle path params
                     pathPrams[currentParam.paramName] = param;
+                    //#endregion
                 }
                 if (currentParam.paramType === 'Query') {
+                    //#region handle query params
                     if (currentParam.paramName) {
-                        const mapping = Mapping.decode(param, !ctx.isProductionMode);
+                        const mapping = decodeMappingForHeaderJson(param, optionsDecodeHeader);
                         if (mapping) {
-                            rest.headers.set(`${Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
+                            requestHeaders.set(`${Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
                         }
                         queryParams[currentParam.paramName] = param;
                     }
                     else {
-                        const mapping = Mapping.decode(param, !ctx.isProductionMode);
+                        const mapping = decodeMappingForHeaderJson(param, optionsDecodeHeader);
                         if (mapping) {
-                            rest.headers.set(Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS, JSON.stringify(mapping));
+                            requestHeaders.set(Symbols.old.MAPPING_CONFIG_HEADER_QUERY_PARAMS, JSON.stringify(mapping));
                         }
                         queryParams = _.cloneDeep(param);
                     }
+                    //#endregion
                 }
                 if (currentParam.paramType === 'Header') {
+                    //#region handler header params
                     if (currentParam.paramName) {
                         if (currentParam.paramName === Symbols.old.MDC_KEY) {
                             // parese MDC
-                            rest.headers.set(currentParam.paramName, encodeURIComponent(JSON.stringify(param)));
+                            requestHeaders.set(currentParam.paramName, encodeURIComponent(JSON.stringify(param)));
                         }
                         else {
-                            rest.headers.set(currentParam.paramName, param);
+                            requestHeaders.set(currentParam.paramName, param);
                         }
                     }
                     else {
                         for (let header in param) {
-                            rest.headers.set(header, param[header]);
+                            requestHeaders.set(header, param[header]);
                         }
                     }
+                    //#endregion
                 }
                 if (currentParam.paramType === 'Cookie') {
+                    //#region handle cookie params
                     Resource.Cookies.write(currentParam.paramName, param, currentParam.expireInSeconds);
+                    //#endregion
                 }
                 if (currentParam.paramType === 'Body') {
+                    //#region handle body params
                     if (currentParam.paramName) {
                         if (ClassHelpers.getName(bodyObject) === 'FormData') {
+                            //#region prevent posting/putting not full body as FormData
                             throw new Error(`[taon - framework] Don use param names when posting / putting FormData.
               Use this:
 // ...
@@ -4989,45 +5044,52 @@ instead
   (@Taon.Http.Param.Body('${currentParam.paramName}') formData: FormData) ...
 // ...
 `);
+                            //#endregion
                         }
-                        const mapping = Mapping.decode(param, !ctx.isProductionMode);
+                        const mapping = decodeMappingForHeaderJson(param, optionsDecodeHeader);
                         if (mapping) {
-                            rest.headers.set(`${Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
+                            requestHeaders.set(`${Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS}${currentParam.paramName} `, JSON.stringify(mapping));
                         }
                         bodyObject[currentParam.paramName] = param;
                     }
                     else {
-                        const mapping = Mapping.decode(param, !ctx.isProductionMode);
+                        const mapping = decodeMappingForHeaderJson(param, optionsDecodeHeader);
                         if (mapping) {
-                            rest.headers.set(Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS, JSON.stringify(mapping));
+                            requestHeaders.set(Symbols.old.MAPPING_CONFIG_HEADER_BODY_PARAMS, JSON.stringify(mapping));
                         }
                         bodyObject = param;
                     }
+                    //#endregion
                 }
             });
             if (typeof bodyObject === 'object' &&
                 ClassHelpers.getName(bodyObject) !== 'FormData') {
+                //#region handle circular objects in body params
                 let circuralFromItem = [];
                 bodyObject = JSON10.parse(JSON10.stringify(bodyObject, void 0, void 0, circs => {
                     circuralFromItem = circs;
                 }));
-                rest.headers.set(Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, JSON10.stringify(circuralFromItem));
+                requestHeaders.set(Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, JSON10.stringify(circuralFromItem));
+                //#endregion
             }
             if (typeof queryParams === 'object') {
+                //#region handle circular objects in query params
                 let circuralFromQueryParams = [];
                 queryParams = JSON10.parse(JSON10.stringify(queryParams, void 0, void 0, circs => {
                     circuralFromQueryParams = circs;
                 }));
-                rest.headers.set(Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM, JSON10.stringify(circuralFromQueryParams));
+                requestHeaders.set(Symbols.old.CIRCURAL_OBJECTS_MAP_QUERY_PARAM, JSON10.stringify(circuralFromQueryParams));
+                //#endregion
             }
             //#endregion
             const httpResultObj = {
                 get received() {
-                    return rest.model(pathPrams)[method](bodyObject, [queryParams]);
+                    return rest
+                        .model(pathPrams, { headers: requestHeaders })[method](bodyObject, [queryParams]);
                 },
                 request(axiosConfig) {
                     return rest
-                        .model(pathPrams)[method](bodyObject, [queryParams], axiosConfig);
+                        .model(pathPrams, { headers: requestHeaders })[method](bodyObject, [queryParams], axiosConfig);
                 },
             };
             return httpResultObj;
@@ -5467,10 +5529,6 @@ const singleTransform = (json) => {
 };
 //#endregion
 class EntityProcess {
-    //#region init
-    static async init(result, response) {
-        return await new EntityProcess(result, response).run();
-    }
     //#endregion
     //#region constructor
     constructor(
@@ -5544,11 +5602,15 @@ class EntityProcess {
             ].includes(className);
         // console.log('doNothing', doNothing)
         if (!doNothing) {
-            const cleaned = JSON10.cleaned(this.data, void 0, {
-                breadthWalk: true,
-                include,
+            // TODO not needed ?
+            // const cleaned = JSON10.cleaned(this.data, void 0, {
+            //   breadthWalk: true,
+            //   include,
+            // });
+            // decodeMappingForHeaderJson is handling nested objects ok
+            this.entityMapping = decodeMappingForHeaderJson(this.data, {
+                useFirstArrayItemClassNameForAllElements: !this.advancedManipulation,
             });
-            this.entityMapping = Mapping.decode(cleaned, !this.advancedManipulation);
             this.response.set(Symbols.old.MAPPING_CONFIG_HEADER, JSON.stringify(this.entityMapping));
             if (this.advancedManipulation) {
                 this.response.set(Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, JSON.stringify(this.circural));
@@ -5789,10 +5851,21 @@ function TaonEntity(options) {
     return function (constructor) {
         options = options || {};
         options.uniqueKeyProp = options.uniqueKeyProp || 'id';
+        if (!options.className) {
+            const nameForClass = constructor?.name || 'AnyClass';
+            throw `Please define 'classname' property inside decorator of class '${nameForClass}':
+
+      @TaonEntity({
+        className: '${nameForClass}'
+      })
+      class ${constructor?.name} {
+      //...
+
+      `;
+        }
         ClassHelpers.setName(constructor, options?.className);
-        Mapping.DefaultModelWithMapping(options?.defaultModelValues || {}, _.merge(options?.defaultModelMapping || {}, (options?.defaultModelMappingDeep || {})))(constructor);
-        // TODO when entit metadata generator read use this
-        Mapping.DefaultModelWithMapping(void 0, {})(constructor);
+        DefaultMapping(options?.defaultModelMapping)(constructor);
+        DefaultModel(options.defaultModelMapping)(constructor);
         Reflect.defineMetadata(Symbols.metadata.options.entity, options, constructor);
         Reflect.defineMetadata(Symbols.metadata.className, options?.className || constructor.name, constructor);
         /* */
@@ -7908,9 +7981,9 @@ function getFromlyConfigFor(target, options = {}) {
     if (level === maxLevel) {
         return [];
     }
-    const mapping = Mapping.getModelsMapping(target);
+    const mapping = decodeMappingForHeaderJson(target);
     // console.log('mapping', mapping)
-    const fieldNames = CLASS.describeProperites(target);
+    const fieldNames = Object.keys(mapping);
     const checkExclude = _.isArray(keysPathesToExclude) && keysPathesToExclude.length > 0;
     const checkInclude = _.isArray(keysPathesToInclude) && keysPathesToInclude.length > 0;
     if (checkExclude && checkInclude) {