taon 21.0.18 → 21.0.28

package/lib-prod/dependency-injection/di-container.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DITaonContainer = void 0;
+class DITaonContainer {
+    static instances = new Map();
+    static resolve(target) {
+        if (DITaonContainer.instances.has(target)) {
+            return DITaonContainer.instances.get(target);
+        }
+        // const tokens = Reflect.getMetadata('design:paramtypes', target) || [];
+        const injections = []; //  tokens.map(token => Container.inject<any>(token));
+        const instance = new target(...injections);
+        DITaonContainer.instances.set(target, instance);
+        return instance;
+    }
+    static inject(target) {
+        return new Proxy({}, {
+            get: (_, propName) => {
+                let instance = DITaonContainer.instances.get(target) ||
+                    DITaonContainer.resolve(target);
+                return typeof instance[propName] === 'function'
+                    ? instance[propName].bind(instance)
+                    : instance[propName];
+            },
+            set: (_, propName, value) => {
+                let instance = DITaonContainer.instances.get(target) ||
+                    DITaonContainer.resolve(target);
+                instance[propName] = value;
+                return true;
+            },
+        });
+    }
+}
+exports.DITaonContainer = DITaonContainer;
+//# sourceMappingURL=di-container.js.map

package/lib-prod/dependency-injection/di-container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"di-container.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;AAAA,MAAa,eAAe;IAClB,MAAM,CAAC,SAAS,GAAG,IAAI,GAAG,EAAE,CAAC;IAErC,MAAM,CAAC,OAAO,CAAI,MAAgB;QAChC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1C,OAAO,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC/C,CAAC;QAED,yEAAyE;QACzE,MAAM,UAAU,GAAG,EAAE,CAAC,CAAC,sDAAsD;QAE7E,MAAM,QAAQ,GAAG,IAAK,MAAc,CAAC,GAAG,UAAU,CAAC,CAAC;QACpD,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAChD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM,CAAC,MAAM,CAAI,MAAiC;QAChD,OAAO,IAAI,KAAK,CACd,EAAE,EACF;YACE,GAAG,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE;gBACnB,IAAI,QAAQ,GACV,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC;oBACrC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBAClC,OAAO,OAAO,QAAQ,CAAC,QAAQ,CAAC,KAAK,UAAU;oBAC7C,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;oBACnC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACzB,CAAC;YACD,GAAG,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE;gBAC1B,IAAI,QAAQ,GACV,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC;oBACrC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBAClC,QAAQ,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC;gBAC3B,OAAO,IAAI,CAAC;YACd,CAAC;SACF,CACG,CAAC;IACT,CAAC;;AArCH,0CAsCC"}

package/lib-prod/endpoint-context-storage.d.ts

@@ -0,0 +1,11 @@
+import type { EndpointContext } from './endpoint-context';
+export declare class ContextsEndpointStorage {
+    SPECIAL_APP_READY_MESSAGE: string;
+    private taonEndpointContexts;
+    private static instance;
+    private constructor();
+    static get Instance(): ContextsEndpointStorage;
+    set(context: EndpointContext): void;
+    get arr(): EndpointContext[];
+    getBy(context: Partial<EndpointContext> | string): EndpointContext | undefined;
+}

package/lib-prod/endpoint-context-storage.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextsEndpointStorage = void 0;
+const lib_prod_1 = require("tnp-core/lib-prod");
+class ContextsEndpointStorage {
+    SPECIAL_APP_READY_MESSAGE = lib_prod_1.CoreModels.SPECIAL_APP_READY_MESSAGE;
+    taonEndpointContexts = new Map();
+    //#region singleton
+    static instance;
+    constructor() {
+        // Private constructor to prevent direct instantiation
+    }
+    static get Instance() {
+        if (!ContextsEndpointStorage.instance) {
+            ContextsEndpointStorage.instance = new ContextsEndpointStorage();
+        }
+        return ContextsEndpointStorage.instance;
+    }
+    //#endregion
+    set(context) {
+        if (!this.taonEndpointContexts.has(context.contextName)) {
+            this.taonEndpointContexts.set(context.contextName, context);
+        }
+    }
+    get arr() {
+        return Array.from(this.taonEndpointContexts.values()).filter(f => f.contextType === 'normal');
+    }
+    getBy(context) {
+        if (typeof context === 'string') {
+            return this.taonEndpointContexts.get(context);
+        }
+        return this.taonEndpointContexts.get(context.contextName);
+    }
+}
+exports.ContextsEndpointStorage = ContextsEndpointStorage;
+// TODO QUICK_FIX @LAST encapsulate this => move to separate package
+globalThis['$$$ContextsEndpointStorage$$$'] = ContextsEndpointStorage.Instance;
+//# sourceMappingURL=endpoint-context-storage.js.map

package/lib-prod/endpoint-context-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-context-storage.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;AAAA,gDAA+C;AAI/C,MAAa,uBAAuB;IAClC,yBAAyB,GAAG,qBAAU,CAAC,yBAAyB,CAAC;IACzD,oBAAoB,GAAG,IAAI,GAAG,EAA2B,CAAC;IAElE,mBAAmB;IACX,MAAM,CAAC,QAAQ,CAA0B;IAEjD;QACE,sDAAsD;IACxD,CAAC;IAEM,MAAM,KAAK,QAAQ;QACxB,IAAI,CAAC,uBAAuB,CAAC,QAAQ,EAAE,CAAC;YACtC,uBAAuB,CAAC,QAAQ,GAAG,IAAI,uBAAuB,EAAE,CAAC;QACnE,CAAC;QACD,OAAO,uBAAuB,CAAC,QAAQ,CAAC;IAC1C,CAAC;IACD,YAAY;IAEZ,GAAG,CAAC,OAAwB;QAC1B,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;YACxD,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAED,IAAI,GAAG;QACL,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAC1D,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,QAAQ,CAChC,CAAC;IACJ,CAAC;IAED,KAAK,CACH,OAA0C;QAE1C,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,OAAO,CAAQ,CAAC;QACvD,CAAC;QACD,OAAO,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAQ,CAAC;IACnE,CAAC;CACF;AAvCD,0DAuCC;AAED,oEAAoE;AACpE,UAAU,CAAC,+BAA+B,CAAC,GAAG,uBAAuB,CAAC,QAAQ,CAAC"}

package/lib-prod/endpoint-context.d.ts

@@ -0,0 +1,196 @@
+import type { Server } from 'http';
+import { URL } from 'url';
+import * as express from 'express';
+import type { Application } from 'express';
+import type { Repository } from 'taon-typeorm/lib-prod';
+import { DataSource } from 'taon-typeorm/lib-prod';
+import type { TaonBaseInjector } from './base-classes/base-injector';
+import { ContextDbMigrations } from './context-db-migrations';
+import type { ContextsEndpointStorage } from './endpoint-context-storage';
+import { Models } from './models';
+export declare class EndpointContext {
+    private originalConfig;
+    private configFn;
+    /**
+     * (@default: false)
+     * If TRUE context is NOT going to create db/express server/http endpoints
+     * PURPOSE OF THIS PROPERTY
+     * -> ONLY remote access from backend or frontend to specific backend
+     */
+    private readonly cloneOptions;
+    /**
+     * JUST FOR TESTING PURPOSES
+     */
+    readonly USE_MARIADB_MYSQL_IN_DOCKER: boolean;
+    disabledRealtime: boolean;
+    /**
+     * check whether context is inited
+     * (with init() function )
+     */
+    inited: boolean;
+    readonly dbMigrations: ContextDbMigrations;
+    private readonly localInstaceObjSymbol;
+    /**
+     * all instances of classes from context
+     * key is class name
+     */
+    readonly allClassesInstances: {};
+    private readonly classInstancesByNameObj;
+    private readonly objWithClassesInstancesArr;
+    readonly activeRoutes: {
+        expressPath: string;
+        method: Models.Http.Rest.HttpMethod;
+    }[];
+    repos: Map<string, Repository<any>>;
+    get sourceContext(): EndpointContext | undefined;
+    readonly skipWritingServerRoutes: boolean;
+    private injectableTypesfromContexts;
+    private allTypesfromContexts;
+    expressApp: Application;
+    serverTcpUdp: Server;
+    databaseConfig?: Models.DatabaseConfigTypeOrm;
+    mode: Models.FrameworkMode;
+    readonly onlyMigrationRun?: boolean;
+    readonly onlyMigrationRevertToTimestamp?: number;
+    get isRunOrRevertOnlyMigrationAppStart(): boolean;
+    session?: Models.ISession;
+    connection: DataSource;
+    private entitiesTriggers;
+    private realtime;
+    get realtimeClient(): import(".").RealtimeClient;
+    get realtimeServer(): import(".").RealtimeServer;
+    /**
+     * available after init()
+     */
+    config: Models.ContextOptions<any, any, any, any, any, any, any, any>;
+    get logHttp(): boolean;
+    get logRealtime(): boolean;
+    get logFramework(): boolean;
+    get logRoutes(): boolean;
+    get logDb(): boolean;
+    get logMigrations(): boolean;
+    /**
+     * Inside docker there is not need for https secure server
+     */
+    readonly isRunningInsideDocker: boolean;
+    constructor(originalConfig: Models.ContextOptions<any, any, any, any, any, any, any, any>, configFn: (env: any) => Models.ContextOptions<any, any, any, any, any, any, any, any>, 
+    /**
+     * (@default: false)
+     * If TRUE context is NOT going to create db/express server/http endpoints
+     * PURPOSE OF THIS PROPERTY
+     * -> ONLY remote access from backend or frontend to specific backend
+     */
+    cloneOptions: Models.TaonCtxCloneParams);
+    init(options?: {
+        initFromRecrusiveContextResovle?: boolean;
+        onlyMigrationRun?: boolean;
+        onlyMigrationRevertToTimestamp?: number;
+    }): Promise<void>;
+    private getAutoGeneratedConfig;
+    startServer(): Promise<void>;
+    displayRoutes(app: any): void;
+    get modeAllowsDatabaseCreation(): boolean;
+    private cloneClassWithNewMetadata;
+    private cloneClassesObjWithNewMetadata;
+    private getRecrusiveClassesfromContextsObj;
+    private getRecrusiveClassesfromContexts;
+    getClassInstanceObjBy(classType: Models.ClassType): any;
+    private getClassesInstancesArrBy;
+    inject<T>(ctor: new (...args: any[]) => T, options: {
+        localInstance?: boolean;
+        contextClassInstance?: TaonBaseInjector;
+        locaInstanceConstructorArgs?: ConstructorParameters<typeof ctor>;
+        parentInstanceThatWillGetInjectedStuff: object;
+    }): T;
+    /**
+     * alias for inject
+     */
+    getInstanceBy<T>(ctor: new (...args: any[]) => T): T;
+    checkIfContextInitialized(): void;
+    getClassFunBy(classType: Models.ClassType): any;
+    isCLassType(classType: Models.ClassType, classFn: Function): boolean;
+    /**
+     * Only for injectable types
+     * Only for classType: CONTROLLER, REPOSITORY, PROVIDER, MIDDLEWARES
+     */
+    getClassFunByClassName(className: string): Function;
+    getClassFunByClass(classFunction: Function): Function;
+    getClassFunByArr(classType: Models.ClassType): Function[];
+    private createInstances;
+    initClasses(): Promise<void>;
+    isActiveOn(classInstance: object): boolean;
+    get frontendHostUri(): URL;
+    get uri(): URL | undefined;
+    get uriProtocol(): string | undefined;
+    /**
+     * Examples
+     * http://localhost:3000
+     * https://localhost (from localhost:80)   *
+     */
+    get uriOrigin(): string | undefined;
+    /**
+     * Exampels
+     * http://localhost:3000/path/to/somewhere
+     * https://localhost/path/to/somewhere (from localhost:80)
+     */
+    get uriPathname(): string | undefined;
+    /**
+     * Examples
+     * http://localhost:3000/path/to/somewhere -> '/path/to/somewhere'
+     * http://localhost:3000 -> '' #
+     * https://localhost/path/to/  -> '/path/to/somewhere' # remove last slash
+     */
+    get uriPathnameOrNothingIfRoot(): string;
+    get uriPort(): string | undefined;
+    /**
+     * Port from uri as number
+     * @returns {Number | undefined}
+     */
+    get port(): Number | undefined;
+    get isHttpServer(): boolean;
+    /**
+     * Check if context is for remote only
+     */
+    get isRemoteHost(): boolean;
+    /**
+     * ipc/udp needs this
+     */
+    get contextName(): string;
+    /**
+     * ipc/udp needs this
+     */
+    get contextNameForCommunication(): string;
+    /**
+     * Check context type
+     */
+    get contextType(): 'normal' | 'remote' | 'abstract' | 'invalid';
+    get cwd(): string;
+    get activeContext(): string | null;
+    get appId(): string;
+    get publicAssets(): {
+        serverPath: string;
+        locationOnDisk: string;
+    }[];
+    get isProductionMode(): boolean;
+    get host(): string | undefined;
+    get origin(): string | undefined;
+    initSubscribers(): Promise<void>;
+    initEntities(): Promise<void>;
+    destroy(): Promise<void>;
+    initDatabaseConnection(): Promise<void>;
+    private updateCalculatedPathsForControllers;
+    private mergeControllerMethodsConfigs;
+    initControllersHook(ctxStorage: ContextsEndpointStorage): Promise<void>;
+    initControllers(): Promise<void>;
+    writeActiveRoutes(): void;
+    get middlewares(): Models.MiddlewareType[];
+    private initCustomClientMiddlewares;
+    private initCustomBackendMiddlewares;
+    private initBackendMiddlewares;
+    private initServer;
+    protected sendError(res: express.Response, error: unknown, req: express.Request, expressPath: string): void;
+    /**
+     * client can be browser or nodejs (when remote host)
+     */
+    private initClient;
+}