taon 21.0.52 → 21.0.54

package/lib-prod/create-context.js

@@ -0,0 +1,217 @@
+//#region imports
+import { ___NS__isString, Helpers__NS__log, UtilsOs__NS__isRunningInDocker } from 'tnp-core/lib-prod';
+import { EndpointContext } from './endpoint-context';
+/* */
+import { ContextsEndpointStorage } from './endpoint-context-storage';
+//#endregion
+/**
+ * @returns function that returns context function.
+ * Context function can be used to dynamically
+ * create context with specific configuration.
+ */
+export const createContextTemplate = (configFn) => {
+    return () => {
+        return createContext(configFn);
+    };
+};
+/**
+ * REQURIED PROPERTY:
+ * - contextName
+ */
+const createContextFn = (configFn, cloneOptions) => {
+    cloneOptions = cloneOptions || {};
+    let config = configFn({});
+    // console.log(
+    //   `
+    //   [Taon] Creating context ${config.contextName}...`,
+    //   {config},
+    // );
+    const endpointContextRef = new EndpointContext(config, configFn, cloneOptions);
+    const res = {
+        //#region contexts
+        get contextName() {
+            return config.contextName;
+        },
+        //#endregion
+        get appId() {
+            return config.appId;
+        },
+        cloneAsRemote: (cloneOpt) => {
+            cloneOpt = cloneOpt || {};
+            const opt = {
+                ...cloneOpt,
+                sourceContext: endpointContextRef,
+                useAsRemoteContext: true,
+            };
+            return createContextFn(configFn, opt);
+        },
+        cloneAsNormal: (cloneOpt) => {
+            cloneOpt = cloneOpt || {};
+            const opt = {
+                ...cloneOpt,
+                sourceContext: endpointContextRef,
+                useAsRemoteContext: false,
+            };
+            return createContextFn(configFn, opt);
+        },
+        //#region context
+        /**
+         * @deprecated
+         * - get reference to internal context
+         */
+        async __ref() {
+            if (!endpointContextRef.inited) {
+                await endpointContextRef.init({
+                    initFromRecrusiveContextResovle: true,
+                });
+            }
+            return endpointContextRef;
+        },
+        /**
+         * only for internal use
+         * @deprecated
+         */
+        get __refSync() {
+            return endpointContextRef;
+        },
+        getClassInstance(ctor) {
+            return endpointContextRef.getInstanceBy(ctor);
+        },
+        getClass(ctor) {
+            const classFun = endpointContextRef.getClassFunByClass(ctor);
+            return classFun;
+            //#region old
+            // TODO hmmmm for now context for controller inside api service
+            // const allContexts = Object.values(classFun[Symbols__NS__orignalClassClonesObj] || {}).map(classFn => {
+            //   return {
+            //     ctx: classFn[Symbols__NS__ctxInClassOrClassObj] as EndpointContext,
+            //     classFn,
+            //   }
+            // })
+            // const activeContext = allContexts.find(c => c.ctx.inited);
+            // debugger
+            // console.log('activeContext', activeContext.ctx.contextName);
+            // return activeContext.ctx.getClassFunByClass(ctor) as any;
+            //#endregion
+        },
+        //#endregion
+        //#region initialize
+        /**
+         * - create controller instances for context
+         * - init database (if enable) + migation scripts
+         */
+        initialize: async (overrideOptions) => {
+            return await new Promise(async (resolve, reject) => {
+                //#region init in set timeout
+                setTimeout(async () => {
+                    if (UtilsOs__NS__isRunningInDocker()) {
+                        const activeContext = config?.activeContext || null;
+                        if (___NS__isString(activeContext) &&
+                            activeContext !== '' &&
+                            activeContext !== config?.contextName) {
+                            console.warn(`[taon] Context ${endpointContextRef.contextName} is not active context, skipping initialization.`);
+                            resolve(endpointContextRef);
+                            return;
+                        }
+                    }
+                    await endpointContextRef.init({
+                        ...overrideOptions,
+                    });
+                    if (config.abstract) {
+                        throw new Error(`Abstract context can not be initialized`);
+                    }
+                    await endpointContextRef.initEntities();
+                    await endpointContextRef.initSubscribers();
+                    await endpointContextRef.initDatabaseConnection();
+                    await endpointContextRef.dbMigrations.ensureMigrationTableExists();
+                    // console.log(
+                    //   'connection subscribers',
+                    //   endpointContextRef?.connection?.subscribers,
+                    // );
+                    // debugger;
+                    await endpointContextRef.initControllers();
+                    await endpointContextRef.startServer();
+                    //#region @websql
+                    endpointContextRef.writeActiveRoutes();
+                    //#endregion
+                    await endpointContextRef.initClasses();
+                    if (endpointContextRef.databaseConfig) {
+                        //#region handle websql reload data
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        /* */
+                        //#endregion
+                        //#region TODO this may be usefull but for now
+                        // 2 separate contexts are fine
+                        // const shouldStartRemoteHost = endpointContextRef.mode !== 'remote-backend(tcp+udp)';
+                        // if(shouldStartRemoteHost) {
+                        //   const endpointContextRemoteHostRef = new EndpointContext(config, configFn);
+                        //   await endpointContextRemoteHostRef.init({
+                        //     overrideRemoteHost: endpointContextRef.host,
+                        //     overrideHost: null,
+                        //   });
+                        //   endpointContextRemoteHostRef.initMetadata();
+                        //   endpointContextRef.__contextForControllerInstanceAccess = endpointContextRemoteHostRef;
+                        // }
+                        //#endregion
+                        //#region run migrations tasks
+                        if (endpointContextRef.onlyMigrationRun) {
+                            endpointContextRef.logMigrations &&
+                                Helpers__NS__log(`[taon] Running only migrations (context=${endpointContextRef.contextName}).`);
+                            await endpointContextRef.dbMigrations.runAllNotCompletedMigrations();
+                        }
+                        else if (endpointContextRef.onlyMigrationRevertToTimestamp) {
+                            endpointContextRef.logMigrations &&
+                                Helpers__NS__log(`[taon] Reverting migrations to timestamp ${endpointContextRef.onlyMigrationRevertToTimestamp} (context=${endpointContextRef.contextName}).`);
+                            await endpointContextRef.dbMigrations.revertMigrationToTimestamp(endpointContextRef.onlyMigrationRevertToTimestamp);
+                        }
+                        else {
+                            endpointContextRef.logMigrations &&
+                                Helpers__NS__log(`[taon] Running all not applied migrations (context=${endpointContextRef.contextName}).`);
+                            await endpointContextRef.dbMigrations.runAllNotCompletedMigrations();
+                        }
+                        //#endregion
+                    }
+                    ContextsEndpointStorage.Instance.set(endpointContextRef);
+                    resolve(endpointContextRef);
+                });
+                //#endregion
+            });
+        },
+        /**
+         * realtime communication with server
+         * TCP(upgrade) socket.io (or ipc) based.
+         */
+        get realtime() {
+            return {
+                get client() {
+                    return endpointContextRef.realtimeClient;
+                },
+                get server() {
+                    return endpointContextRef.realtimeServer;
+                },
+            };
+        },
+    };
+    return res;
+};
+//#endregion
+export const createContext = (configFn) => {
+    return createContextFn(configFn, { useAsRemoteContext: false });
+};
+// const AA = createContext(() => ({ contextName: 'aa' }));
+// const BB = AA.cloneAsRemoteContext();

package/lib-prod/decorators/classes/controller-decorator.js

@@ -0,0 +1,17 @@
+import { ClassHelpers__NS__ensureClassConfig, ClassHelpers__NS__setName } from '../../helpers/class-helpers';
+import { Symbols__NS__metadata } from '../../symbols';
+/**
+ * Controller decorator
+ */
+export function TaonController(options) {
+    return function (constructor) {
+        ClassHelpers__NS__setName(constructor, options?.className);
+        Reflect.defineMetadata(Symbols__NS__metadata.className, options?.className || constructor.name, constructor);
+        const cfg = ClassHelpers__NS__ensureClassConfig(constructor);
+        options = options || {};
+        cfg.className = options.className || constructor.name;
+        cfg.path = options.path || '';
+        cfg.realtime = options.realtime;
+        cfg.middlewares = options.middlewares;
+    };
+}

package/lib-prod/decorators/classes/entity-decorator.js

@@ -0,0 +1,28 @@
+import { Mapping__NS__DefaultModelWithMapping } from 'ng2-rest/lib-prod';
+import { Entity } from 'taon-typeorm/lib-prod';
+import { ___NS__merge } from 'tnp-core/lib-prod';
+import { CLASS } from 'typescript-class-helpers/lib-prod';
+import { ClassHelpers__NS__setName } from '../../helpers/class-helpers';
+import { Symbols__NS__metadata } from '../../symbols';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
+/**
+ * Entity decorator
+ */
+export function TaonEntity(options) {
+    return function (constructor) {
+        options = options || {};
+        options.uniqueKeyProp = options.uniqueKeyProp || 'id';
+        ClassHelpers__NS__setName(constructor, options?.className);
+        Mapping__NS__DefaultModelWithMapping(options?.defaultModelValues || {}, ___NS__merge(options?.defaultModelMapping || {}, (options?.defaultModelMappingDeep || {})))(constructor);
+        // TODO when entit metadata generator read use this
+        Mapping__NS__DefaultModelWithMapping(void 0, {})(constructor);
+        Reflect.defineMetadata(Symbols__NS__metadata.options.entity, options, constructor);
+        Reflect.defineMetadata(Symbols__NS__metadata.className, options?.className || constructor.name, constructor);
+        //#region @websql
+        Entity(options?.className)(constructor);
+        //#endregion
+        CLASS.setName(constructor, options?.className); // TODO QUICK_FIX for ng2-rest
+    };
+}
+export class TaonEntityOptions extends DecoratorAbstractOpt {
+}

package/lib-prod/decorators/classes/middleware-decorator.js

@@ -0,0 +1,16 @@
+import 'reflect-metadata';
+import { ClassHelpers__NS__setName } from '../../helpers/class-helpers';
+import { Symbols__NS__metadata } from '../../symbols';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
+/**
+ * Provider decorator
+ */
+export function TaonMiddleware(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols__NS__metadata.options.provider, options, constructor);
+        Reflect.defineMetadata(Symbols__NS__metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers__NS__setName(constructor, options?.className || constructor.name);
+    };
+}
+export class TaonMiddlewareOptions extends DecoratorAbstractOpt {
+}

package/lib-prod/decorators/classes/migration-decorator.js

@@ -0,0 +1,15 @@
+import { ClassHelpers__NS__setName } from '../../helpers/class-helpers';
+import { Symbols__NS__metadata } from '../../symbols';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
+/**
+ * Migration decorator
+ */
+export function TaonMigration(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols__NS__metadata.options.migration, options, constructor);
+        Reflect.defineMetadata(Symbols__NS__metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers__NS__setName(constructor, options?.className);
+    };
+}
+export class TaonMigrationOptions extends DecoratorAbstractOpt {
+}

package/lib-prod/decorators/classes/provider-decorator.js

@@ -0,0 +1,15 @@
+import { ClassHelpers__NS__setName } from '../../helpers/class-helpers';
+import { Symbols__NS__metadata } from '../../symbols';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
+/**
+ * Provider decorator
+ */
+export function TaonProvider(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols__NS__metadata.options.provider, options, constructor);
+        Reflect.defineMetadata(Symbols__NS__metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers__NS__setName(constructor, options?.className || constructor.name);
+    };
+}
+export class TaonProviderOptions extends DecoratorAbstractOpt {
+}

package/lib-prod/decorators/classes/repository-decorator.js

@@ -0,0 +1,15 @@
+import { ClassHelpers__NS__setName } from '../../helpers/class-helpers';
+import { Symbols__NS__metadata } from '../../symbols';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
+/**
+ * Repository decorator
+ */
+export function TaonRepository(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols__NS__metadata.options.repository, options, constructor);
+        Reflect.defineMetadata(Symbols__NS__metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers__NS__setName(constructor, options?.className);
+    };
+}
+export class TaonRepositoryOptions extends DecoratorAbstractOpt {
+}

package/lib-prod/decorators/classes/subscriber-decorator.js

@@ -0,0 +1,15 @@
+import { ClassHelpers__NS__setName } from '../../helpers/class-helpers';
+import { Symbols__NS__metadata } from '../../symbols';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
+/**
+ * Subscriber decorator
+ */
+export function TaonSubscriber(options) {
+    return function (constructor) {
+        Reflect.defineMetadata(Symbols__NS__metadata.options.subscriber, options, constructor);
+        Reflect.defineMetadata(Symbols__NS__metadata.className, options?.className || constructor.name, constructor);
+        ClassHelpers__NS__setName(constructor, options?.className);
+    };
+}
+export class TaonSubscriberOptions extends DecoratorAbstractOpt {
+}

package/lib-prod/decorators/decorator-abstract-opt.js

@@ -0,0 +1,2 @@
+export class DecoratorAbstractOpt {
+}

package/lib-prod/decorators/http/http-decorators.js

@@ -0,0 +1,20 @@
+import { Models } from 'ng2-rest/lib-prod';
+export const HttpResponse = Models.HttpResponse;
+// TODO new 5.8 typescript is not allowing this
+// export namespace Http {
+//   export import GET = methods.GET;
+//   export import POST = methods.POST;
+//   export import PUT = methods.PUT;
+//   export import DELETE = methods.DELETE;
+//   export import PATCH = methods.PATCH;
+//   export import HEAD = methods.HEAD;
+//   export import HTML = methods.HTML;
+//   export import Response = Models.HttpResponse;
+//   export namespace Param {
+//     export import Query = params.Query;
+//     export import Path = params.Path;
+//     export import Body = params.Body;
+//     export import Cookie = params.Cookie;
+//     export import Header = params.Header;
+//   }
+// }

package/lib-prod/decorators/http/http-methods-decorators.js

@@ -0,0 +1,102 @@
+import { ___NS__isString } from 'tnp-core/lib-prod';
+import { ClassHelpers__NS__ensureMethodConfig } from '../../helpers/class-helpers';
+const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal) => {
+    const methodConfig = ClassHelpers__NS__ensureMethodConfig(target, propertyKey);
+    let options;
+    if (typeof pathOrOptions === 'object') {
+        options = pathOrOptions;
+        pathOrOptions = options.path;
+        pathIsGlobal = !!options.pathIsGlobal;
+        path = options.path;
+    }
+    else {
+        options = { pathOrOptions, pathIsGlobal };
+    }
+    const { overrideContentType, overrideResponseType, overrideExpressSendAsHtml, middlewares, } = options;
+    methodConfig.methodName = propertyKey;
+    methodConfig.middlewares = middlewares;
+    methodConfig.type = method;
+    if (!path) {
+        let paramsPathConcatedPath = '';
+        for (const key in methodConfig.parameters) {
+            if (methodConfig.parameters.hasOwnProperty(key)) {
+                const element = methodConfig.parameters[key];
+                if (element.paramType === 'Path' &&
+                    ___NS__isString(element.paramName) &&
+                    element.paramName.trim().length > 0) {
+                    paramsPathConcatedPath += `/${element.paramName}/:${element.paramName}`;
+                }
+            }
+        }
+        methodConfig.path = `/${propertyKey}${paramsPathConcatedPath}`;
+    }
+    else {
+        methodConfig.path = path;
+    }
+    methodConfig.descriptor = descriptor;
+    methodConfig.global = pathIsGlobal;
+    methodConfig.contentType = overrideContentType;
+    methodConfig.responseType = overrideResponseType;
+    methodConfig.overrideExpressSendAsHtml = overrideExpressSendAsHtml;
+};
+export function GET(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('get', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+/**
+ * Method for sending html website from text
+ * Example
+ *
+ * ```ts
+ * ...
+ * // in your taon controller
+ * ..Taon.Http.HTML()
+ * sendHtmlDummyWebsite(): Taon.ResponseHtml {
+ *  return  `
+      <html>
+        <head>
+          <title>Dummy website</title>
+        </head>
+        <body>
+          <h1>This is dummy website</h1>
+          <p>Served as HTML string from Taon controller method</p>
+        </body>
+      </html>
+ *  `; *
+ * }
+ * ...
+ * ```
+ */
+export function HTML(pathOrOptions) {
+    return function (target, propertyKey, descriptor) {
+        const opt = pathOrOptions;
+        opt.overrideExpressSendAsHtml = true;
+        metaReq('get', opt, target, propertyKey, descriptor, pathOrOptions, opt.pathIsGlobal);
+    };
+}
+export function HEAD(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('head', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+export function POST(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('post', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+export function PUT(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('put', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+export function PATCH(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('patch', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}
+export function DELETE(pathOrOptions, pathIsGlobal = false) {
+    return function (target, propertyKey, descriptor) {
+        metaReq('delete', pathOrOptions, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal);
+    };
+}

package/lib-prod/decorators/http/http-params-decorators.js

@@ -0,0 +1,42 @@
+import { ClassHelpers__NS__ensureMethodConfig } from '../../helpers/class-helpers';
+function metaParam(param, name, expire, defaultValue = undefined, target, propertyKey, parameterIndex) {
+    const methodCfg = ClassHelpers__NS__ensureMethodConfig(target, propertyKey);
+    const nameKey = name ? name : param;
+    // const key = name || `${param}_${parameterIndex}`;
+    methodCfg.parameters[nameKey] = {
+        index: parameterIndex,
+        paramName: name,
+        paramType: param,
+        defaultType: defaultValue,
+        expireInSeconds: expire,
+    };
+    // console.log('params updated', methodConfig);
+}
+/**
+ * @deprecated use Taon.Http.Param.Path (is more safe and cleaner)
+ */
+export function Path(name) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Path', name, undefined, {}, target, propertyKey, parameterIndex);
+    };
+}
+export function Query(name) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Query', name, undefined, {}, target, propertyKey, parameterIndex);
+    };
+}
+export function Cookie(name, expireInSecond = 3600) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Cookie', name, expireInSecond, {}, target, propertyKey, parameterIndex);
+    };
+}
+export function Header(name) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Header', name, undefined, {}, target, propertyKey, parameterIndex);
+    };
+}
+export function Body(name) {
+    return function (target, propertyKey, parameterIndex) {
+        metaParam('Body', name, undefined, {}, target, propertyKey, parameterIndex);
+    };
+}

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

@@ -0,0 +1,30 @@
+export class DITaonContainer {
+    static { this.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;
+            },
+        });
+    }
+}

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

@@ -0,0 +1,31 @@
+import { CoreModels__NS__SPECIAL_APP_READY_MESSAGE } from 'tnp-core/lib-prod';
+export class ContextsEndpointStorage {
+    constructor() {
+        this.SPECIAL_APP_READY_MESSAGE = CoreModels__NS__SPECIAL_APP_READY_MESSAGE;
+        this.taonEndpointContexts = new Map();
+        // 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);
+    }
+}
+// TODO QUICK_FIX @LAST encapsulate this => move to separate package
+globalThis['$$$ContextsEndpointStorage$$$'] = ContextsEndpointStorage.Instance;