taon 21.0.52 → 21.0.54

package/lib-prod/global-state/taon-global-state/taon-global-state.entity.js

@@ -0,0 +1,35 @@
+//#region imports
+import { CreateDateColumn, CustomColumn } from '../../orm/columns';
+import { TaonGlobalStateDefaultsValues } from './taon-global-state.constants';
+import { TaonBaseAbstractEntity } from '../../base-classes/base-abstract-entity';
+import { TaonEntity } from '../../decorators/classes/entity-decorator';
+//#endregion
+let TAON_GLOBAL_STATE = class TAON_GLOBAL_STATE extends TaonBaseAbstractEntity {
+};
+__decorate([
+    CustomColumn({
+        type: 'varchar',
+        length: 20,
+        nullable: false,
+        default: TaonGlobalStateDefaultsValues.status,
+    })
+    //#endregion
+], TAON_GLOBAL_STATE.prototype, "status", void 0);
+__decorate([
+    CreateDateColumn()
+    //#endregion
+], TAON_GLOBAL_STATE.prototype, "createdAt", void 0);
+__decorate([
+    CustomColumn({
+        type: 'int',
+        nullable: true,
+    })
+    //#endregion
+], TAON_GLOBAL_STATE.prototype, "secondsBeforeReadonly", void 0);
+TAON_GLOBAL_STATE = __decorate([
+    TaonEntity({
+        className: 'TAON_GLOBAL_STATE',
+        createTable: true,
+    })
+], TAON_GLOBAL_STATE);
+export { TAON_GLOBAL_STATE };

package/lib-prod/global-state/taon-global-state/taon-global-state.middleware.js

@@ -0,0 +1,12 @@
+//#region imports
+import { TaonBaseMiddleware } from '../../base-classes/base-middleware';
+import { TaonMiddleware } from '../../decorators/classes/middleware-decorator';
+//#endregion
+let TaonGlobalStateMiddleware = class TaonGlobalStateMiddleware extends TaonBaseMiddleware {
+};
+TaonGlobalStateMiddleware = __decorate([
+    TaonMiddleware({
+        className: 'TaonGlobalStateMiddleware',
+    })
+], TaonGlobalStateMiddleware);
+export { TaonGlobalStateMiddleware };

package/lib-prod/global-state/taon-global-state/taon-global-state.models.js

@@ -0,0 +1,44 @@
+export var TaonGlobalStateStatus;
+(function (TaonGlobalStateStatus) {
+    TaonGlobalStateStatus["NORMAL"] = "normal";
+    /**
+     * no new transactions allowed
+     * existing ones may finish
+     */
+    TaonGlobalStateStatus["DRAINING"] = "draining";
+    /**
+     * DB is readonly
+     * app is readonly (no writes, no side effects)
+     */
+    TaonGlobalStateStatus["READONLY"] = "readonly";
+    /**
+     * Db and app still readonly - migration in progress
+     */
+    TaonGlobalStateStatus["MIGRATING"] = "migrating";
+    /**
+     *  emergency stop / maintenance mode
+     */
+    TaonGlobalStateStatus["FROZEN"] = "frozen";
+})(TaonGlobalStateStatus || (TaonGlobalStateStatus = {}));
+export const allowedTaonGlobalStatusOrders = {
+    [TaonGlobalStateStatus.NORMAL]: [
+        TaonGlobalStateStatus.DRAINING,
+        TaonGlobalStateStatus.FROZEN,
+    ],
+    [TaonGlobalStateStatus.DRAINING]: [
+        TaonGlobalStateStatus.READONLY,
+        TaonGlobalStateStatus.FROZEN,
+    ],
+    [TaonGlobalStateStatus.READONLY]: [
+        TaonGlobalStateStatus.MIGRATING,
+        TaonGlobalStateStatus.NORMAL,
+        TaonGlobalStateStatus.FROZEN,
+    ],
+    [TaonGlobalStateStatus.MIGRATING]: [
+        TaonGlobalStateStatus.READONLY
+    ],
+    [TaonGlobalStateStatus.FROZEN]: [
+        TaonGlobalStateStatus.READONLY,
+        TaonGlobalStateStatus.NORMAL,
+    ],
+};

package/lib-prod/global-state/taon-global-state/taon-global-state.provider.js

@@ -0,0 +1,12 @@
+//#region imports
+import { TaonBaseProvider } from '../../base-classes/base-provider';
+import { TaonProvider } from '../../decorators/classes/provider-decorator';
+//#endregion
+let TaonGlobalStateProvider = class TaonGlobalStateProvider extends TaonBaseProvider {
+};
+TaonGlobalStateProvider = __decorate([
+    TaonProvider({
+        className: 'TaonGlobalStateProvider',
+    })
+], TaonGlobalStateProvider);
+export { TaonGlobalStateProvider };

package/lib-prod/global-state/taon-global-state/taon-global-state.repository.js

@@ -0,0 +1,46 @@
+//#region imports
+import { TaonBaseRepository } from '../../base-classes/base-repository';
+import { TaonRepository } from '../../decorators/classes/repository-decorator';
+import { TAON_GLOBAL_STATE } from './taon-global-state.entity';
+import { TaonGlobalStateStatus } from './taon-global-state.models';
+import { TaonGlobalStateUtils__NS__assertAllowedTransition } from './taon-global-state.utils';
+//#endregion
+let TaonGlobalStateRepository = class TaonGlobalStateRepository extends TaonBaseRepository {
+    constructor() {
+        super(...arguments);
+        this.entityClassResolveFn = () => TAON_GLOBAL_STATE;
+    }
+    async getLastStatus() {
+        //#region @websqlFunc
+        const lastStatus = await this.findOne({
+            order: { createdAt: 'DESC' },
+        });
+        return lastStatus;
+        //#endregion
+    }
+    async setDraining(secondsBeforeReadonly = 0) {
+        //#region @websqlFunc
+        await this.transitionTo(TaonGlobalStateStatus.DRAINING);
+        if (secondsBeforeReadonly > 0) {
+            setTimeout(async () => {
+                await this.transitionTo(TaonGlobalStateStatus.READONLY);
+            }, secondsBeforeReadonly);
+        }
+        //#endregion
+    }
+    async transitionTo(next) {
+        //#region @websqlFunc
+        const current = await this.getLastStatus();
+        TaonGlobalStateUtils__NS__assertAllowedTransition(current.status, next);
+        const newState = this.create({ status: next });
+        await this.save(newState);
+        return newState;
+        //#endregion
+    }
+};
+TaonGlobalStateRepository = __decorate([
+    TaonRepository({
+        className: 'TaonGlobalStateRepository',
+    })
+], TaonGlobalStateRepository);
+export { TaonGlobalStateRepository };

package/lib-prod/global-state/taon-global-state/taon-global-state.subscriber.js

@@ -0,0 +1,22 @@
+//#region imports
+import { TaonBaseSubscriberForEntity } from '../../base-classes/base-subscriber-for-entity';
+import { TaonSubscriber } from '../../decorators/classes/subscriber-decorator';
+import { TAON_GLOBAL_STATE } from './taon-global-state.entity';
+import { TaonGlobalStateProvider } from './taon-global-state.provider';
+//#endregion
+let TaonGlobalStateSubscriber = class TaonGlobalStateSubscriber extends TaonBaseSubscriberForEntity {
+    constructor() {
+        super(...arguments);
+        this.taonGlobalStateProvider = this.injectProvider(TaonGlobalStateProvider);
+    }
+    listenTo() {
+        return TAON_GLOBAL_STATE;
+    }
+};
+TaonGlobalStateSubscriber = __decorate([
+    TaonSubscriber({
+        className: 'TaonGlobalStateSubscriber',
+        // allowedEvents: ['afterUpdate'],
+    })
+], TaonGlobalStateSubscriber);
+export { TaonGlobalStateSubscriber };

package/lib-prod/global-state/taon-global-state/taon-global-state.utils.js

@@ -0,0 +1,11 @@
+import { allowedTaonGlobalStatusOrders, } from './taon-global-state.models';
+//namespace TaonGlobalStateUtils
+// export function isActive(state: string): state is TaonGlobalStateStatus {
+//   return state === 'active';
+// }
+export const TaonGlobalStateUtils__NS__assertAllowedTransition = (from, to) => {
+    if (!allowedTaonGlobalStatusOrders[from]?.includes(to)) {
+        throw new Error(`Invalid state transition: ${from} → ${to}`);
+    }
+};
+//end of namespace TaonGlobalStateUtils

package/lib-prod/global-state/taon-transaction-registry/{index.ts → index.js}

@@ -1,4 +1,4 @@
-/* */                                                                
+/* */
 export * from './taon-transaction-registry.abstract.context';
 export * from './taon-transaction-registry.constants';
 export * from './taon-transaction-registry.controller';
@@ -8,4 +8,4 @@ export * from './taon-transaction-registry.models';
 export * from './taon-transaction-registry.provider';
 export * from './taon-transaction-registry.repository';
 export * from './taon-transaction-registry.subscriber';
-export * from './taon-transaction-registry.utils';
+export * from './taon-transaction-registry.utils';

package/lib-prod/global-state/taon-transaction-registry/{taon-transaction-registry.abstract.context.ts → taon-transaction-registry.abstract.context.js}

@@ -1,7 +1,6 @@
 //#region imports
 import { TaonBaseContext } from '../../base-classes/base-context';
 import { createContext } from '../../create-context';
-
 import { TaonTransactionRegistryController } from './taon-transaction-registry.controller';
 import { TAON_TANSACTION_REGISTRY } from './taon-transaction-registry.entity';
 import { TaonTransactionRegistryMiddleware } from './taon-transaction-registry.middleware';
@@ -9,15 +8,14 @@ import { TaonTransactionRegistryProvider } from './taon-transaction-registry.pro
 import { TaonTransactionRegistryRepository } from './taon-transaction-registry.repository';
 import { TaonTransactionRegistrySubscriber } from './taon-transaction-registry.subscriber';
 //#endregion
-
 export const TaonTransactionRegistryContext = createContext(() => ({
-  contextName: 'TaonTransactionRegistryContext',
-  abstract: true,
-  contexts: { TaonBaseContext },
-  entities: { TAON_TANSACTION_REGISTRY },
-  controllers: { TaonTransactionRegistryController },
-  repositories: { TaonTransactionRegistryRepository },
-  providers: { TaonTransactionRegistryProvider },
-  middlewares: { TaonTransactionRegistryMiddleware },
-  subscribers: { TaonTransactionRegistrySubscriber },
-}));
+    contextName: 'TaonTransactionRegistryContext',
+    abstract: true,
+    contexts: { TaonBaseContext },
+    entities: { TAON_TANSACTION_REGISTRY },
+    controllers: { TaonTransactionRegistryController },
+    repositories: { TaonTransactionRegistryRepository },
+    providers: { TaonTransactionRegistryProvider },
+    middlewares: { TaonTransactionRegistryMiddleware },
+    subscribers: { TaonTransactionRegistrySubscriber },
+}));

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.constants.js

@@ -0,0 +1,5 @@
+export const TaonTransactionRegistryDefaultsValues = {
+    description: '',
+    version: 0,
+    id: void 0,
+};

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.controller.js

@@ -0,0 +1,36 @@
+//#region imports
+import { TaonController } from '../../decorators/classes/controller-decorator';
+import { TaonBaseCrudController } from '../../base-classes/base-crud-controller';
+import { Query } from '../../decorators/http/http-params-decorators';
+import { POST } from '../../decorators/http/http-methods-decorators';
+import { TAON_TANSACTION_REGISTRY } from './taon-transaction-registry.entity';
+import { TaonTransactionRegistryRepository } from './taon-transaction-registry.repository';
+//#endregion
+let TaonTransactionRegistryController = class TaonTransactionRegistryController extends TaonBaseCrudController {
+    constructor() {
+        super(...arguments);
+        this.entityClassResolveFn = () => TAON_TANSACTION_REGISTRY;
+        this.taonTransactionRegistryRepository = this.injectCustomRepo(TaonTransactionRegistryRepository);
+        //#endregion
+    }
+    //#region methods & getters / hello world
+    startTransaction(yourName) {
+        //#region @websqlFunc
+        return async (req, res) => {
+            // TODO @LAST
+            //  return this.taonTransactionRegistryRepository.startTransaction(yourName);
+            return void 0;
+        };
+        //#endregion
+    }
+};
+__decorate([
+    POST(),
+    __param(0, Query('serviceName'))
+], TaonTransactionRegistryController.prototype, "startTransaction", null);
+TaonTransactionRegistryController = __decorate([
+    TaonController({
+        className: 'TaonTransactionRegistryController',
+    })
+], TaonTransactionRegistryController);
+export { TaonTransactionRegistryController };

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.entity.js

@@ -0,0 +1,36 @@
+//#region imports
+import { CreateDateColumn, NumberColumn, String100Column, String20Column, } from '../../orm/columns';
+import { DateTimeColumn } from '../../orm/columns';
+import { TaonBaseAbstractEntity } from '../../base-classes/base-abstract-entity';
+import { TaonEntity } from '../../decorators/classes/entity-decorator';
+import { TaonTransactionRegistryState } from './taon-transaction-registry.models';
+//#endregion
+let TAON_TANSACTION_REGISTRY = class TAON_TANSACTION_REGISTRY extends TaonBaseAbstractEntity {
+};
+__decorate([
+    NumberColumn()
+    //#endregion
+], TAON_TANSACTION_REGISTRY.prototype, "workerIndex", void 0);
+__decorate([
+    String100Column()
+    //#endregion
+], TAON_TANSACTION_REGISTRY.prototype, "contextName", void 0);
+__decorate([
+    CreateDateColumn()
+    //#endregion
+], TAON_TANSACTION_REGISTRY.prototype, "startedAt", void 0);
+__decorate([
+    DateTimeColumn()
+    //#endregion
+], TAON_TANSACTION_REGISTRY.prototype, "finishedAt", void 0);
+__decorate([
+    String20Column(TaonTransactionRegistryState.RUNNING)
+    //#endregion
+], TAON_TANSACTION_REGISTRY.prototype, "state", void 0);
+TAON_TANSACTION_REGISTRY = __decorate([
+    TaonEntity({
+        className: 'TAON_TANSACTION_REGISTRY',
+        createTable: true,
+    })
+], TAON_TANSACTION_REGISTRY);
+export { TAON_TANSACTION_REGISTRY };

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.middleware.js

@@ -0,0 +1,12 @@
+//#region imports
+import { TaonBaseMiddleware } from '../../base-classes/base-middleware';
+import { TaonMiddleware } from '../../decorators/classes/middleware-decorator';
+//#endregion
+let TaonTransactionRegistryMiddleware = class TaonTransactionRegistryMiddleware extends TaonBaseMiddleware {
+};
+TaonTransactionRegistryMiddleware = __decorate([
+    TaonMiddleware({
+        className: 'TaonTransactionRegistryMiddleware',
+    })
+], TaonTransactionRegistryMiddleware);
+export { TaonTransactionRegistryMiddleware };

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.models.js

@@ -0,0 +1,7 @@
+export var TaonTransactionRegistryState;
+(function (TaonTransactionRegistryState) {
+    TaonTransactionRegistryState["RUNNING"] = "running";
+    TaonTransactionRegistryState["COMMITTED"] = "committed";
+    TaonTransactionRegistryState["ROLLED_BACK"] = "rolled_back";
+    TaonTransactionRegistryState["ABANDONED"] = "abandoned";
+})(TaonTransactionRegistryState || (TaonTransactionRegistryState = {}));

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.provider.js

@@ -0,0 +1,12 @@
+//#region imports
+import { TaonBaseProvider } from '../../base-classes/base-provider';
+import { TaonProvider } from '../../decorators/classes/provider-decorator';
+//#endregion
+let TaonTransactionRegistryProvider = class TaonTransactionRegistryProvider extends TaonBaseProvider {
+};
+TaonTransactionRegistryProvider = __decorate([
+    TaonProvider({
+        className: 'TaonTransactionRegistryProvider',
+    })
+], TaonTransactionRegistryProvider);
+export { TaonTransactionRegistryProvider };

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.repository.js

@@ -0,0 +1,31 @@
+//#region imports
+import { TaonBaseRepository } from '../../base-classes/base-repository';
+import { TaonRepository } from '../../decorators/classes/repository-decorator';
+import { Raw } from 'taon-typeorm/lib-prod';
+import { TAON_TANSACTION_REGISTRY } from './taon-transaction-registry.entity';
+//#endregion
+let TaonTransactionRegistryRepository = class TaonTransactionRegistryRepository extends TaonBaseRepository {
+    constructor() {
+        super(...arguments);
+        this.entityClassResolveFn = () => TAON_TANSACTION_REGISTRY;
+    }
+    /**
+     * TODO remove this demo example method
+     */
+    async countEntitesWithEvenId() {
+        //#region @websqlFunc
+        const result = await this.count({
+            where: {
+                id: Raw(alias => `${alias} % 2 = 0`),
+            },
+        });
+        return result;
+        //#endregion
+    }
+};
+TaonTransactionRegistryRepository = __decorate([
+    TaonRepository({
+        className: 'TaonTransactionRegistryRepository',
+    })
+], TaonTransactionRegistryRepository);
+export { TaonTransactionRegistryRepository };

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.subscriber.js

@@ -0,0 +1,22 @@
+//#region imports
+import { TaonBaseSubscriberForEntity } from '../../base-classes/base-subscriber-for-entity';
+import { TaonSubscriber } from '../../decorators/classes/subscriber-decorator';
+import { TAON_TANSACTION_REGISTRY } from './taon-transaction-registry.entity';
+import { TaonTransactionRegistryProvider } from './taon-transaction-registry.provider';
+//#endregion
+let TaonTransactionRegistrySubscriber = class TaonTransactionRegistrySubscriber extends TaonBaseSubscriberForEntity {
+    constructor() {
+        super(...arguments);
+        this.taonTransactionRegistryProvider = this.injectProvider(TaonTransactionRegistryProvider);
+    }
+    listenTo() {
+        return TAON_TANSACTION_REGISTRY;
+    }
+};
+TaonTransactionRegistrySubscriber = __decorate([
+    TaonSubscriber({
+        className: 'TaonTransactionRegistrySubscriber',
+        // allowedEvents: ['afterUpdate'],
+    })
+], TaonTransactionRegistrySubscriber);
+export { TaonTransactionRegistrySubscriber };

package/lib-prod/global-state/taon-transaction-registry/taon-transaction-registry.utils.js

@@ -0,0 +1,5 @@
+//namespace TaonTransactionRegistryUtils
+export function TaonTransactionRegistryUtils__NS__isActive(state) {
+    return state === 'active';
+}
+//end of namespace TaonTransactionRegistryUtils

package/lib-prod/helpers/class-helpers.js

@@ -0,0 +1,228 @@
+//#region imports
+import * as FormData from 'form-data'; // @backend
+import { ___NS__isArray, ___NS__isArrayBuffer, ___NS__isBuffer, ___NS__isDate, ___NS__isFunction, ___NS__isNull, ___NS__isObject, ___NS__isRegExp, ___NS__isString, ___NS__isUndefined, ___NS__uniq, Utils__NS__uniqArray } from 'tnp-core/lib-prod';
+import { CLASS } from 'typescript-class-helpers/lib-prod';
+import { controllerConfigFrom, } from '../config/controller-config';
+import { Symbols__NS__classNameStaticProperty, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__orignalClass } from '../symbols';
+import { Validators__NS__classNameVlidation } from '../validators';
+//#endregion
+//namespace ClassHelpers
+//#region get class from name
+/**
+ * TODO - repalce in every place when getting class fn from object
+ */
+export const ClassHelpers__NS__getClassFnFromObject = (json) => {
+    if (___NS__isUndefined(json) || ___NS__isNull(json)) {
+        return;
+    }
+    if (json.constructor) {
+        return json.constructor;
+    }
+    const p = Object.getPrototypeOf(json);
+    return p && p.constructor && p.constructor.name !== 'Object'
+        ? p.constructor
+        : void 0;
+};
+//#endregion
+//#region get name
+export const ClassHelpers__NS__getName = (classFnOrObject) => {
+    // exception for FormData
+    if (classFnOrObject instanceof FormData) {
+        return 'FormData';
+    }
+    if (!classFnOrObject) {
+        console.error('OBJECT OR CLASS', classFnOrObject);
+        throw new Error(`Cannot get name from this object or class.`);
+    }
+    return ((classFnOrObject[Symbols__NS__classNameStaticProperty]
+        ? classFnOrObject[Symbols__NS__classNameStaticProperty]
+        : classFnOrObject?.constructor[Symbols__NS__classNameStaticProperty]) ||
+        (___NS__isFunction(classFnOrObject) ? CLASS.getName(classFnOrObject) : void 0));
+};
+//#endregion
+export const ClassHelpers__NS__getOrginalClass = (classFnOrObject) => {
+    const org = classFnOrObject[Symbols__NS__orignalClass];
+    if (!org) {
+        return classFnOrObject;
+    }
+    return ClassHelpers__NS__getOrginalClass(org);
+};
+//#region get full internal name
+export const ClassHelpers__NS__getFullInternalName = (classFnOrObject) => {
+    // exception for FormData
+    if (!classFnOrObject) {
+        throw new Error(`Cannot get name from: ${classFnOrObject}`);
+    }
+    return ((classFnOrObject[Symbols__NS__fullClassNameStaticProperty]
+        ? classFnOrObject[Symbols__NS__fullClassNameStaticProperty]
+        : classFnOrObject?.constructor[Symbols__NS__fullClassNameStaticProperty]) ||
+        void 0);
+};
+//#endregion
+//#region get unique key
+export const ClassHelpers__NS__getUniqueKey = (classFnOrObject) => {
+    const classFn = ___NS__isFunction(classFnOrObject)
+        ? classFnOrObject
+        : classFnOrObject.constructor;
+    const config = Reflect.getMetadata(Symbols__NS__metadata.options.entity, classFn);
+    return config.uniqueKeyProp;
+};
+//#endregion
+//#region is class object
+export const ClassHelpers__NS__isContextClassObject = (obj) => {
+    if (!___NS__isObject(obj) ||
+        ___NS__isArray(obj) ||
+        ___NS__isRegExp(obj) ||
+        ___NS__isBuffer(obj) ||
+        ___NS__isArrayBuffer(obj)) {
+        return false;
+    }
+    if (___NS__isDate(obj)) {
+        return true;
+    }
+    const className = ClassHelpers__NS__getName(obj);
+    return ___NS__isString(className) && className !== 'Object';
+};
+//#endregion
+//#region get name
+export const ClassHelpers__NS__setName = (target, className) => {
+    // console.log('setName', className, target.name)
+    Validators__NS__classNameVlidation(className, target);
+    target[Symbols__NS__classNameStaticProperty] = className;
+};
+//#endregion
+//#region has parent with class name
+export const ClassHelpers__NS__hasParentClassWithName = (target, className, targets = []) => {
+    if (!target) {
+        return false;
+    }
+    targets.push(target);
+    let targetProto = Object.getPrototypeOf(target);
+    if (___NS__isFunction(targetProto) &&
+        ClassHelpers__NS__getName(targetProto) === className) {
+        // console.log(`true  "${___NS__first(targets).name}" for ${targets.map(d => d.name).join(',')}`)
+        return true;
+    }
+    return ClassHelpers__NS__hasParentClassWithName(targetProto, className, targets);
+};
+//#endregion
+//#region get methods name
+//#region not allowed as method name
+const notAllowedAsMethodName = [
+    'length',
+    'name',
+    'arguments',
+    'caller',
+    'constructor',
+    'apply',
+    'bind',
+    'call',
+    'toString',
+    '__defineGetter__',
+    '__defineSetter__',
+    'hasOwnProperty',
+    '__lookupGetter__',
+    '__lookupSetter__',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'valueOf',
+    '__proto__',
+    'toLocaleString',
+];
+//#endregion
+/**
+ * Express async handler for middleware functions.
+ */
+export const ClassHelpers__NS__asyncHandler = fn => (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+};
+export const ClassHelpers__NS__getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
+    if (!classOrClassInstance) {
+        return Utils__NS__uniqArray(allMethodsNames);
+    }
+    const isClassFunction = ___NS__isFunction(classOrClassInstance);
+    const classFun = isClassFunction
+        ? classOrClassInstance
+        : Object.getPrototypeOf(classOrClassInstance);
+    const objectToCheck = isClassFunction
+        ? classOrClassInstance?.prototype
+        : classOrClassInstance;
+    const prototypeObj = Object.getPrototypeOf(objectToCheck || {});
+    const properties = ___NS__uniq([
+        ...Object.getOwnPropertyNames(objectToCheck || {}),
+        ...Object.getOwnPropertyNames(prototypeObj || {}),
+        ...Object.keys(objectToCheck || {}),
+        ...Object.keys(prototypeObj || {}),
+    ]).filter(f => !!f && !notAllowedAsMethodName.includes(f));
+    properties
+        .filter(methodName => typeof objectToCheck[methodName] === 'function')
+        .forEach(p => allMethodsNames.push(p));
+    if (!classFun ||
+        !classFun.constructor ||
+        classFun?.constructor?.name === 'Object') {
+        return Utils__NS__uniqArray(allMethodsNames);
+    }
+    return ClassHelpers__NS__getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
+};
+//#endregion
+//#region get controller configs
+export const ClassHelpers__NS__getControllerConfigs = (target, configs = [], callerTarget) => {
+    if (!___NS__isFunction(target)) {
+        throw `[typescript-class-helper][getControllerConfigs] Cannot get class config from: ${target}`;
+    }
+    let config;
+    const parentClass = Object.getPrototypeOf(target);
+    const parentName = parentClass ? ClassHelpers__NS__getName(parentClass) : void 0;
+    const isValidParent = ___NS__isFunction(parentClass) && parentName !== '';
+    config = controllerConfigFrom(ClassHelpers__NS__getClassConfig(target));
+    configs.push(config);
+    return isValidParent
+        ? ClassHelpers__NS__getControllerConfigs(parentClass, configs, target)
+        : configs;
+};
+//#endregion
+//#region ensure configs
+// Ensure ClassConfig on constructor, clone parent if needed
+export const ClassHelpers__NS__ensureClassConfig = (target) => {
+    let cfg = Reflect.getOwnMetadata(Symbols__NS__metadata.options.controller, // META_KEYS.class,
+    target);
+    if (!cfg) {
+        cfg = { methods: {} };
+        const parent = Object.getPrototypeOf(target);
+        if (parent && parent !== Function.prototype) {
+            const parentCfg = Reflect.getMetadata(Symbols__NS__metadata.options.controller, // META_KEYS.class,
+            parent);
+            if (parentCfg) {
+                // Deep copy each method config so child gets its own objects
+                const clonedMethods = {};
+                for (const [k, v] of Object.entries(parentCfg.methods)) {
+                    clonedMethods[k] = {
+                        ...v,
+                        parameters: { ...v.parameters }, // shallow clone parameters too
+                    };
+                }
+                cfg = {
+                    ...parentCfg,
+                    methods: clonedMethods,
+                };
+            }
+        }
+        Reflect.defineMetadata(Symbols__NS__metadata.options.controller, cfg, target);
+    }
+    return cfg;
+};
+// Ensure MethodConfig inside ClassConfig
+export const ClassHelpers__NS__ensureMethodConfig = (target, propertyKey) => {
+    const classCfg = ClassHelpers__NS__ensureClassConfig(target.constructor);
+    let methodCfg = classCfg.methods[propertyKey?.toString()];
+    if (!methodCfg) {
+        methodCfg = { methodName: propertyKey?.toString(), parameters: {} };
+        classCfg.methods[propertyKey?.toString()] = methodCfg;
+    }
+    return methodCfg;
+};
+export const ClassHelpers__NS__getClassConfig = (constructor) => {
+    return Reflect.getMetadata(Symbols__NS__metadata.options.controller, constructor);
+};
+//#endregion
+//end of namespace ClassHelpers

package/lib-prod/helpers/clone-obj.js

@@ -0,0 +1,17 @@
+import { walk } from 'lodash-walk-object/lib-prod';
+import { ___NS__cloneDeep, ___NS__isFunction, ___NS__isNil, ___NS__isObject, ___NS__merge, ___NS__set } from 'tnp-core/lib-prod';
+export const cloneObj = (override, classFn) => {
+    const result = ___NS__merge(new classFn(), ___NS__cloneDeep(this));
+    walk.Object(override || {}, (value, lodashPath) => {
+        if (___NS__isNil(value) || ___NS__isFunction(value) || ___NS__isObject(value)) {
+            // skipping
+        }
+        else {
+            ___NS__set(result, lodashPath, value);
+        }
+    }, {
+        walkGetters: false,
+    });
+    // console.log({result})
+    return result;
+};