taon 0.0.0 → 18.0.12

package/browser/esm2022/lib/index.mjs

@@ -0,0 +1,79 @@
+import 'reflect-metadata';
+import * as http from './decorators/http/http-decorators';
+import * as base from './base-classes/base';
+import * as controllerDecorator from './decorators/classes/controller-decorator';
+import * as entityDecorator from './decorators/classes/entity-decorator';
+import * as providerDecorator from './decorators/classes/provider-decorator';
+import * as repositoryDecorator from './decorators/classes/repository-decorator';
+import * as subscriberDecorator from './decorators/classes/subscriber-decorator';
+import * as createContextFn from './create-context';
+import * as coreHelpers from 'tnp-core/browser';
+import * as injectFn from './inject';
+import * as endpointContext from './endpoint-context';
+import * as allSymbols from './symbols';
+import * as getResponse from './get-response-value';
+export { BaseRepository } from './base-classes/base-repository';
+export { BaseController } from './base-classes/base-controller';
+export { BaseProvider } from './base-classes/base-provider';
+export { BaseSubscriber } from './base-classes/base-subscriber';
+export { BaseEntity } from './base-classes/base-entity';
+export { BaseContext } from './base-classes/base-context';
+export { createContext } from './create-context';
+export { inject } from './inject';
+export { Models } from './models';
+export * from './constants';
+export { ClassHelpers } from './helpers/class-helpers';
+export var Taon;
+(function (Taon) {
+    Taon.Http = http.Http;
+    Taon.Base = base.Base;
+    Taon.getResponseValue = getResponse.getResponseValue;
+    Taon.Controller = controllerDecorator.TaonController;
+    Taon.Entity = entityDecorator.TaonEntity;
+    Taon.Provider = providerDecorator.TaonProvider;
+    Taon.Repository = repositoryDecorator.TaonRepository;
+    Taon.Subscriber = subscriberDecorator.TaonSubscriber;
+    /**
+     * @deprecated
+     */
+    Taon.isBrowser = coreHelpers.Helpers.isBrowser;
+    /**
+     * @deprecated
+     */
+    Taon.isNode = coreHelpers.Helpers.isNode;
+    /**
+     * @deprecated
+     */
+    Taon.isWebSQL = coreHelpers.Helpers.isWebSQL;
+    /**
+     * @deprecated
+     */
+    Taon.isElectron = coreHelpers.Helpers.isElectron;
+    Taon.createContext = createContextFn.createContext;
+    Taon.inject = injectFn.inject;
+    Taon.initNgZone = (ngZone) => {
+        endpointContext.EndpointContext.initNgZone(ngZone);
+    };
+    Taon.symbols = allSymbols.Symbols;
+    /**
+     * @deprecated
+     * use createContext instead
+     */
+    Taon.init = async (options) => {
+        const BaseContext = (await import('./base-classes/base-context'))
+            .BaseContext;
+        const context = Taon.createContext(() => ({
+            contextName: 'default',
+            host: options.host,
+            contexts: { BaseContext },
+            database: true,
+            entities: Array.from(options.entities),
+            controllers: Array.from(options.controllers),
+        }));
+        await context.initialize();
+        return context;
+    };
+})(Taon || (Taon = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/index.ts
+//# sourceMappingURL=data:application/json;base64,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

package/browser/esm2022/lib/inject.mjs

@@ -0,0 +1,70 @@
+import { inject as angularInject } from '@angular/core';
+import { Symbols } from './symbols';
+import { Subject } from 'rxjs';
+export const inject = (entity) => {
+    return new Proxy({}, {
+        get: (_, propName) => {
+            if (propName === 'hasOwnProperty') {
+                return () => false;
+            }
+            const ctor = entity();
+            const contextFromClass = ctor[Symbols.ctxInClassOrClassObj];
+            const resultContext = contextFromClass;
+            if (resultContext) {
+                let instance = resultContext.inject(ctor);
+                if (propName === 'getOriginalPrototype') {
+                    return () => Object.getPrototypeOf(instance);
+                }
+                if (propName === 'getOriginalConstructor') {
+                    return () => instance.constructor;
+                }
+                const methods = ctor[Symbols.classMethodsNames] || [];
+                const isMethods = methods.includes(propName);
+                const methodOrProperty = isMethods
+                    ? instance[propName].bind(instance)
+                    : instance[propName];
+                return methodOrProperty;
+            }
+            return angularInject(ctor)[propName];
+        },
+    });
+};
+export const injectController = inject;
+export const injectSubscriberEvents = (subscriberClassResolveFn, eventName) => {
+    const eventsSrc = new Subject();
+    const obs = eventsSrc.asObservable();
+    let isFirstSubscription = true;
+    const proxiedObservable = new Proxy(obs, {
+        get(target, prop, receiver) {
+            if (prop === 'subscribe') {
+                return (...args) => {
+                    if (isFirstSubscription) {
+                        isFirstSubscription = false;
+                        const subscriberClassFN = subscriberClassResolveFn();
+                        const ctx = subscriberClassFN[Symbols.ctxInClassOrClassObj];
+                        if (!ctx) {
+                            throw new Error(`You are trying to inject class without context. Use context like this;
+
+              Taon.injectSubscriberEvents( ()=> ` +
+                                `MyContext.getInstance(${subscriberClassFN?.name}), '${eventName}' )
+
+
+              `);
+                        }
+                        const subscriberInstance = ctx.getInstanceBy(subscriberClassFN);
+                        console.log('First subscription, you can access arguments here:', {
+                            subscriberClassFN,
+                            eventName,
+                        });
+                    }
+                    return target.subscribe(...args);
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+    return proxiedObservable;
+};
+;
+({}); // @--end-of-file-for-module=taon lib/inject.ts
+//# sourceMappingURL=data:application/json;base64,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

package/browser/esm2022/lib/models.mjs

@@ -0,0 +1,77 @@
+/* */
+/* */
+import { Models as ModelsNg2Rest } from 'ng2-rest/browser';
+import { ClassHelpers } from './helpers/class-helpers';
+export var Models;
+(function (Models) {
+    let ClassType;
+    (function (ClassType) {
+        ClassType["ENTITY"] = "ENTITY";
+        ClassType["CONTROLLER"] = "CONTROLLER";
+        ClassType["REPOSITORY"] = "REPOSITORY";
+        ClassType["PROVIDER"] = "PROVIDER";
+        ClassType["SUBSCRIBER"] = "SUBSCRIBER";
+    })(ClassType = Models.ClassType || (Models.ClassType = {}));
+    Models.ClassTypeKey = {
+        [ClassType.ENTITY]: 'entities',
+        [ClassType.CONTROLLER]: 'controllers',
+        [ClassType.REPOSITORY]: 'repositories',
+        [ClassType.PROVIDER]: 'providers',
+        [ClassType.SUBSCRIBER]: 'subscribers',
+    };
+    class DecoratorAbstractOpt {
+    }
+    Models.DecoratorAbstractOpt = DecoratorAbstractOpt;
+    class ParamConfig {
+    }
+    Models.ParamConfig = ParamConfig;
+    class MethodConfig {
+        constructor() {
+            /* */
+            /* */
+            this.parameters = {};
+        }
+    }
+    Models.MethodConfig = MethodConfig;
+    class ControllerConfig extends DecoratorAbstractOpt {
+        constructor() {
+            super(...arguments);
+            this.methods = {};
+        }
+    }
+    Models.ControllerConfig = ControllerConfig;
+    class RuntimeControllerConfig extends ControllerConfig {
+    }
+    Models.RuntimeControllerConfig = RuntimeControllerConfig;
+    let Http;
+    (function (Http) {
+        Http.Rest = ModelsNg2Rest;
+        class Errors {
+            constructor(message, code = 400) {
+                this.message = message;
+                this.code = code;
+                this.toString = () => {
+                    return this.message;
+                };
+            }
+            static create(message, code = 400) {
+                return new Errors(message, code);
+            }
+            static entityNotFound(entity) {
+                return Errors.create(`Entity ${ClassHelpers.getName(entity)} not found`);
+            }
+            static custom(message, code = 400) {
+                return Errors.create(message, code);
+            }
+        }
+        Http.Errors = Errors;
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+    })(Http = Models.Http || (Models.Http = {}));
+})(Models || (Models = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/models.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../tmp-libs-for-dist/taon/projects/taon/src/lib/models.ts"],"names":[],"mappings":"AAKA,KAAK;AACL,KAAK;AAEL,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAIvD,MAAM,KAAW,MAAM,CAoRtB;AApRD,WAAiB,MAAM;IAQrB,IAAY,SAMX;IAND,WAAY,SAAS;QACnB,8BAAiB,CAAA;QACjB,sCAAyB,CAAA;QACzB,sCAAyB,CAAA;QACzB,kCAAqB,CAAA;QACrB,sCAAyB,CAAA;IAC3B,CAAC,EANW,SAAS,GAAT,gBAAS,KAAT,gBAAS,QAMpB;IAEY,mBAAY,GAAG;QAC1B,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,UAAU;QAC9B,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,aAAa;QACrC,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,cAAc;QACtC,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,WAAW;QACjC,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,aAAa;KAGtC,CAAC;IA4GF,MAAa,oBAAoB;KAEhC;IAFY,2BAAoB,uBAEhC,CAAA;IAID,MAAa,WAAW;KAMvB;IANY,kBAAW,cAMvB,CAAA;IAID,MAAa,YAAY;QAAzB;YAiBF,KAAK;YACL,KAAK;YAED,eAAU,GAAyC,EAAE,CAAC;QACxD,CAAC;KAAA;IArBY,mBAAY,eAqBxB,CAAA;IAID,MAAa,gBAAiB,SAAQ,oBAAoB;QAA1D;;YAIE,YAAO,GAA2C,EAAE,CAAC;QACvD,CAAC;KAAA;IALY,uBAAgB,mBAK5B,CAAA;IAID,MAAa,uBAAwB,SAAQ,gBAAgB;KAG5D;IAHY,8BAAuB,0BAGnC,CAAA;IAID,IAAiB,IAAI,CAqFpB;IArFD,WAAiB,IAAI;QACL,SAAI,GAAG,aAAa,CAAC;QA+CnC,MAAa,MAAM;YAKjB,YACS,OAAe,EACd,OAA+B,GAAG;gBADnC,YAAO,GAAP,OAAO,CAAQ;gBACd,SAAI,GAAJ,IAAI,CAA8B;gBANrC,aAAQ,GAAG,GAAW,EAAE;oBAC7B,OAAO,IAAI,CAAC,OAAO,CAAC;gBACtB,CAAC,CAAC;YAKC,CAAC;YAEI,MAAM,CAAC,MAAM,CACnB,OAAe,EACf,OAA+B,GAAG;gBAElC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACnC,CAAC;YAEM,MAAM,CAAC,cAAc,CAAC,MAAiB;gBAC5C,OAAO,MAAM,CAAC,MAAM,CAClB,UAAU,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CACnD,CAAC;YACJ,CAAC;YAEM,MAAM,CAAC,MAAM,CAClB,OAAe,EACf,OAA+B,GAAG;gBAElC,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACtC,CAAC;SACF;QA7BY,WAAM,SA6BlB,CAAA;QAEL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;IAEH,CAAC,EArFgB,IAAI,GAAJ,WAAI,KAAJ,WAAI,QAqFpB;AAEH,CAAC,EApRgB,MAAM,KAAN,MAAM,QAoRtB;AAEA,CAAC;AAAA,CAAC,EAAE,CAAC,CAAC,CAAC,+CAA+C","sourcesContent":["\n\nimport { CoreModels } from 'tnp-core/browser';\nimport { Response, RequestHandler } from 'express';\nimport {   Response as ExpressResponse,   Request as ExpressRequest, } from 'express';/* */\n/* */\n/* */\n\nimport { Models as ModelsNg2Rest } from 'ng2-rest/browser';\nimport { ClassHelpers } from './helpers/class-helpers';\nimport type { TaonControllerOptions } from './decorators/classes/controller-decorator';\nimport type { TaonEntityOptions } from './decorators/classes/entity-decorator';\n\nexport namespace Models {\n  export type FrameworkMode =\n    | 'backend-frontend(tcp+udp)'\n    | 'remote-backend(tcp+udp)'\n    | 'backend-frontend(ipc-electron)'\n    | 'backend-frontend(websql)';\n\n\n  export enum ClassType {\n    ENTITY = 'ENTITY',\n    CONTROLLER = 'CONTROLLER',\n    REPOSITORY = 'REPOSITORY',\n    PROVIDER = 'PROVIDER',\n    SUBSCRIBER = 'SUBSCRIBER',\n  }\n\n  export const ClassTypeKey = {\n    [ClassType.ENTITY]: 'entities',\n    [ClassType.CONTROLLER]: 'controllers',\n    [ClassType.REPOSITORY]: 'repositories',\n    [ClassType.PROVIDER]: 'providers',\n    [ClassType.SUBSCRIBER]: 'subscribers',\n  } as {\n    [key in ClassType]: keyof ContextOptions<any, any, any, any, any, any>;\n  };\n\n\n\n\n  export type MiddlewareType = [Function, any[]];\n\n\n\n  export interface DatabaseConfig {\n    /**\n     * database name\n     */\n    database?: string;\n    /**\n     * only for file base db: sqlite, sqljs\n     */\n    location?: string;\n    synchronize: boolean;\n    dropSchema: boolean;\n    type?: CoreModels.DatabaseType;\n\n    autoSave: boolean; // TODO what is this ?\n    /**\n     * for websql db mode\n     */\n    useLocalForage?: boolean;\n    logging: boolean;\n\n    databasePort?: number;\n    databaseHost?: string;\n    databaseUsername?: string;\n    databasePassword?: string;\n  }\n\n\n\n\n  export type ISession = {\n    secret?: string;\n    saveUninitialized?: boolean;\n    /**\n     * max age of session\n     */\n    cookieMaxAge?: number;\n    secure?: boolean;\n    resave?: boolean;\n  };\n\n\n\n  export type ContectionOptionsLogs = {\n    http: boolean;\n    realtime: boolean;\n    framework: boolean;\n    db: boolean;\n  };\n  export interface ContextOptions<\n    CONTEXTS,\n    CONTROLLERS,\n    ENTITIES,\n    REPOSITORIES,\n    PROVIDERS,\n    SUBSCRIBERS,\n  > {\n    contextName: string;\n    host?: string;\n    /**\n   * frontend host only needed when we are using\n   * withCredentials for axios\n   * and session cookie\n   */\n    frontendHost?: string;\n    remoteHost?: string;\n    useIpcWhenElectron?: boolean;\n    contexts?: CONTEXTS;\n    controllers?: CONTROLLERS;\n    entities?: ENTITIES;\n    repositories?: REPOSITORIES;\n    providers?: PROVIDERS;\n    subscribers?: SUBSCRIBERS;\n    session?: ISession;\n    productionMode?: boolean;\n    abstract?: boolean;\n    logs?: boolean | ContectionOptionsLogs;\n    database?: boolean | DatabaseConfig;\n    disabledRealtime?: boolean;\n    https?: {\n      key: string;\n      cert: string;\n    };\n    publicAssets?: { serverPath: string; locationOnDisk: string }[];\n    middlewares?: MiddlewareType[];\n    /**\n     * @deprecated\n     * only for debugging purpose\n     */\n    override?: {\n      entities?: Function[];\n      controllers?: Function[];\n      repositories?: Function[];\n      providers?: Function[];\n      subscribers?: Function[];\n    };\n  }\n\n\n\n  export class DecoratorAbstractOpt {\n    className: string;\n  }\n\n\n\n  export class ParamConfig {\n    paramName: string;\n    paramType: CoreModels.ParamType;\n    index: number;\n    defaultType: any;\n    expireInSeconds?: number;\n  }\n\n\n\n  export class MethodConfig {\n    methodName: string;\n    /**\n     * path is global in express app\n     */\n    global?: boolean;\n    /**\n     * override default content type\n     */\n    contentType?: any;\n    /**\n     * override default axiso response type\n     */\n    responseType?: any;\n    path: string;\n    descriptor: PropertyDescriptor;\n    type: CoreModels.HttpMethod;\n/* */\n/* */\n  \n    parameters: { [paramName: string]: ParamConfig } = {};\n  }\n\n\n\n  export class ControllerConfig extends DecoratorAbstractOpt {\n    realtime?: boolean;\n    path: string;\n    uniqueKey?: string;\n    methods: { [methodName: string]: MethodConfig } = {};\n  }\n\n\n\n  export class RuntimeControllerConfig extends ControllerConfig {\n    calculatedPath?: string;\n    browserTransformFn?: (entity: any) => any;\n  }\n\n\n\n  export namespace Http {\n    export import Rest = ModelsNg2Rest;\n\n    export type ContextENDPOINT = { target: Function; initFN: Function };\n\n    export type FormlyFromType = 'material' | 'bootstrap';\n\n    export type ExpressContext<T> = (\n      req: ExpressRequest,\n      res: ExpressResponse,\n    ) => T;\n\n    export type SyncResponse<T> = string | T;\n\n    export type ResponseFuncOpt<T> = {\n      limitSize?: (\n        enties: Function | Function[],\n        include: string[],\n        exclude: string[],\n      ) => void;\n    };\n\n    export type SyncResponseFunc<T> = (\n      options?: ResponseFuncOpt<T>,\n    ) => SyncResponse<T>;\n    export type MixResponse<T> = SyncResponse<T> | ExpressContext<T>;\n\n    export interface ClientAction<T> {\n      received?: Rest.PromiseObservableMix<Rest.HttpResponse<T>>;\n    }\n\n    export interface __Response<T> {\n/* */\n/* */\n  \n    }\n\n    export interface AsyncResponse<T> {\n      (\n        req?: ExpressRequest,\n        res?: ExpressResponse,\n      ): Promise<SyncResponse<T> | SyncResponseFunc<T>>;\n    }\n\n    export type Response<T = string> = (__Response<T> | AsyncResponse<T>) &\n      ClientAction<T> &\n      __Response<T>;\n\n    export class Errors {\n      public toString = (): string => {\n        return this.message;\n      };\n\n      private constructor(\n        public message: string,\n        private code: ModelsNg2Rest.HttpCode = 400,\n      ) {}\n\n      private static create(\n        message: string,\n        code: ModelsNg2Rest.HttpCode = 400,\n      ) {\n        return new Errors(message, code);\n      }\n\n      public static entityNotFound(entity?: Function) {\n        return Errors.create(\n          `Entity ${ClassHelpers.getName(entity)} not found`,\n        );\n      }\n\n      public static custom(\n        message: string,\n        code: ModelsNg2Rest.HttpCode = 400,\n      ) {\n        return Errors.create(message, code);\n      }\n    }\n\n/* */\n/* */\n/* */\n/* */\n/* */\n  \n  }\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/models.ts"]}

package/browser/esm2022/lib/orm.mjs

@@ -0,0 +1,6 @@
+/* */
+/* */
+;
+({}); // @--end-of-file-for-module=taon lib/orm.ts
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdG1wLWxpYnMtZm9yLWRpc3QvdGFvbi9wcm9qZWN0cy90YW9uL3NyYy9saWIvb3JtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLEtBQUs7QUFDTCxLQUFLO0FBMkVKLENBQUM7QUFBQSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsNENBQTRDIiwic291cmNlc0NvbnRlbnQiOlsiXG5cbi8qICovXG4vKiAqL1xuICBcblxuXG5leHBvcnQgbmFtZXNwYWNlIE9ybSB7XG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbiAgXG59XG5cblxuXG4gOyh7fSk7IC8vIEAtLWVuZC1vZi1maWxlLWZvci1tb2R1bGU9dGFvbiBsaWIvb3JtLnRzIl19

package/browser/esm2022/lib/realtime/realtime-client.mjs

@@ -0,0 +1,129 @@
+import { _ } from 'tnp-core/browser';
+import { Symbols } from '../symbols';
+import { Observable } from 'rxjs';
+import { ClassHelpers } from '../helpers/class-helpers';
+import { RealtimeSubsManager } from './realtime-subs-manager';
+export class RealtimeClient {
+    constructor(core) {
+        this.core = core;
+        this.subsmanagers = {};
+        this.core = core;
+        if (!core.ctx.disabledRealtime) {
+            this.init();
+        }
+    }
+    init() {
+        const nspPath = {
+            global: this.core.pathFor(),
+            realtime: this.core.pathFor(Symbols.REALTIME.NAMESPACE(this.core.ctx.contextName)),
+        };
+        this.core.ctx.logRealtime &&
+            console.info('[CLIENT] NAMESPACE GLOBAL ', nspPath.global.href + ` host: ${this.core.ctx.host}`);
+        this.core.ctx.logRealtime &&
+            console.info('[CLIENT] NAMESPACE REALTIME', nspPath.realtime.href + ` host: ${this.core.ctx.host}`);
+        this.core.FE = this.core.strategy.io(nspPath.global.origin, {
+            path: nspPath.global.pathname,
+        });
+        if (this.core.FE.on) {
+            this.core.FE.on('connect', () => {
+                console.info(`[CLIENT] conented to GLOBAL namespace ${this.core.FE.id} of host: ${this.core.ctx.host}`);
+            });
+        }
+        this.core.FE_REALTIME = this.core.strategy.io(nspPath.realtime.origin, {
+            path: nspPath.realtime.pathname,
+        });
+        if (this.core.FE_REALTIME.on) {
+            this.core.FE_REALTIME.on('connect', () => {
+                console.info(`[CLIENT] conented to REALTIME namespace ${this.core.FE_REALTIME.id} host: ${this.core.ctx.host}`);
+            });
+        }
+    }
+    /**
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * ...
+     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * ...
+     */
+    listenChangesEntity(entityClassFn, idOrUniqValue, options) {
+        options = options || {};
+        const { property, customEvent } = options;
+        const className = !customEvent && ClassHelpers.getName(entityClassFn);
+        if (_.isString(property)) {
+            if (property.trim() === '') {
+                throw new Error(`[Taon][listenChangesEntity.. incorect property '' for ${className}`);
+            }
+        }
+        return new Observable(observer => {
+            if (this.core.ctx.disabledRealtime) {
+                console.error(`[Taon][realtime rxjs] remove taon config flag:
+
+        ...
+        disabledRealtime: true
+        ...
+
+to use socket realtime connection;
+        `);
+                return () => {
+                };
+            }
+            let roomName;
+            if (customEvent) {
+                roomName = Symbols.REALTIME.ROOM_NAME.CUSTOM(this.core.ctx.contextName, customEvent);
+            }
+            else {
+                roomName = _.isString(property)
+                    ? Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY_PROPERTY(this.core.ctx.contextName, className, property, idOrUniqValue)
+                    : Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY(this.core.ctx.contextName, className, idOrUniqValue);
+            }
+            const roomSubOptions = {
+                core: this.core,
+                property,
+                roomName,
+                customEvent,
+            };
+            const subManagerId = this.getRoomIdFrom(roomSubOptions);
+            if (!this.subsmanagers[subManagerId]) {
+                this.subsmanagers[subManagerId] = new RealtimeSubsManager(roomSubOptions);
+            }
+            const inst = this.subsmanagers[subManagerId];
+            inst.add(observer);
+            inst.startListenIfNotStarted(this.core.FE_REALTIME);
+            return () => {
+                inst.remove(observer);
+            };
+        });
+    }
+    listenChangesEntityTable(entityClassFn) {
+        const className = ClassHelpers.getName(entityClassFn);
+        return this.listenChangesEntity(entityClassFn, void 0, {
+            customEvent: Symbols.REALTIME.TABLE_CHANGE(this.core.ctx.contextName, className),
+        });
+    }
+    /**
+     * Changes trigger on backend needs to be done manually.. example code:
+     *
+     * ...
+     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * // or
+     * Context.Realtime.Server.TrigggerEntityPropertyChanges(myEntityInstance,{ property: 'geolocationX' });
+     * ...
+     */
+    listenChangesEntityObj(entity, options) {
+        const classFn = ClassHelpers.getClassFnFromObject(entity);
+        const uniqueKey = ClassHelpers.getUniquKey(classFn);
+        return this.listenChangesEntity(classFn, entity[uniqueKey], options);
+    }
+    listenChangesCustomEvent(customEvent) {
+        return this.listenChangesEntity(void 0, void 0, {
+            customEvent,
+        });
+    }
+    getRoomIdFrom(options) {
+        const url = new URL(options.core.ctx.host);
+        return `${this.core.ctx.contextName}:${url.origin}|${options.roomName}|${options.property}|${options.customEvent}`;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-client.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"realtime-client.js","sourceRoot":"","sources":["../../../../../tmp-libs-for-dist/taon/projects/taon/src/lib/realtime/realtime-client.ts"],"names":[],"mappings":"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","sourcesContent":["\n\n\nimport { _ } from 'tnp-core/browser';\nimport { RealtimeCore } from './realtime-core';\nimport { Symbols } from '../symbols';\nimport { Observable } from 'rxjs';\nimport { ClassHelpers } from '../helpers/class-helpers';\nimport { RealtimeSubsManager } from './realtime-subs-manager';\nimport { RealtimeModels } from './realtime.models';\nimport type { BaseEntity } from '../base-classes/base-entity';\nimport { Helpers } from 'tnp-core/browser';\n\n\nexport class RealtimeClient {\n  private subsmanagers: { [path: string]: RealtimeSubsManager } = {};\n  constructor(private core: RealtimeCore) {\n    this.core = core;\n    if (!core.ctx.disabledRealtime) {\n\n      this.init();\n\n    }\n  }\n\n\n  private init() {\n\n    const nspPath = {\n      global: this.core.pathFor(),\n      realtime: this.core.pathFor(\n        Symbols.REALTIME.NAMESPACE(this.core.ctx.contextName),\n      ),\n    };\n\n    this.core.ctx.logRealtime &&\n      console.info(\n        '[CLIENT] NAMESPACE GLOBAL ',\n        nspPath.global.href + ` host: ${this.core.ctx.host}`,\n      );\n\n    this.core.ctx.logRealtime &&\n      console.info(\n        '[CLIENT] NAMESPACE REALTIME',\n        nspPath.realtime.href + ` host: ${this.core.ctx.host}`,\n      );\n\n\n\n    this.core.FE = this.core.strategy.io(nspPath.global.origin, {\n      path: nspPath.global.pathname,\n    });\n\n    if (this.core.FE.on) {\n      this.core.FE.on('connect', () => {\n\n\n\n        console.info(\n          `[CLIENT] conented to GLOBAL namespace ${this.core.FE.id} of host: ${this.core.ctx.host}`,\n        );\n      });\n    }\n\n\n\n\n    this.core.FE_REALTIME = this.core.strategy.io(nspPath.realtime.origin, {\n      path: nspPath.realtime.pathname,\n    });\n\n    if (this.core.FE_REALTIME.on) {\n      this.core.FE_REALTIME.on('connect', () => {\n\n\n\n        console.info(\n          `[CLIENT] conented to REALTIME namespace ${this.core.FE_REALTIME.id} host: ${this.core.ctx.host}`,\n        );\n      });\n    }\n\n\n  }\n\n\n\n  /**\n   * Changes trigger on backend needs to be done manually.. example code:\n   *\n   * ...\n   * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);\n   * ...\n   */\n  listenChangesEntity(\n    entityClassFn: Function,\n    idOrUniqValue: any,\n    options: RealtimeModels.ChangeOption,\n  ) {\n    options = options || ({} as any);\n\n\n    const { property, customEvent } = options;\n    const className = !customEvent && ClassHelpers.getName(entityClassFn);\n\n    if (_.isString(property)) {\n      if (property.trim() === '') {\n        throw new Error(\n          `[Taon][listenChangesEntity.. incorect property '' for ${className}`,\n        );\n      }\n    }\n\n\n    return new Observable(observer => {\n\n\n      if (this.core.ctx.disabledRealtime) {\n        console.error(`[Taon][realtime rxjs] remove taon config flag:\n\n        ...\n        disabledRealtime: true\n        ...\n\nto use socket realtime connection;\n        `);\n        return () => {\n\n        };\n      }\n\n      let roomName: string;\n\n      if (customEvent) {\n        roomName = Symbols.REALTIME.ROOM_NAME.CUSTOM(\n          this.core.ctx.contextName,\n          customEvent,\n        );\n      } else {\n        roomName = _.isString(property)\n          ? Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY_PROPERTY(\n              this.core.ctx.contextName,\n              className,\n              property,\n              idOrUniqValue,\n            )\n          : Symbols.REALTIME.ROOM_NAME.UPDATE_ENTITY(\n              this.core.ctx.contextName,\n              className,\n              idOrUniqValue,\n            );\n      }\n\n      const roomSubOptions: RealtimeModels.SubsManagerOpt = {\n        core: this.core,\n        property,\n        roomName,\n        customEvent,\n      };\n\n\n      const subManagerId = this.getRoomIdFrom(roomSubOptions);\n      if (!this.subsmanagers[subManagerId]) {\n        this.subsmanagers[subManagerId] = new RealtimeSubsManager(\n          roomSubOptions,\n        );\n      }\n      const inst = this.subsmanagers[subManagerId];\n      inst.add(observer);\n\n      inst.startListenIfNotStarted(this.core.FE_REALTIME);\n\n      return () => {\n        inst.remove(observer);\n      };\n    });\n  }\n\n\n\n\n  listenChangesEntityTable(entityClassFn: Function) {\n    const className = ClassHelpers.getName(entityClassFn);\n    return this.listenChangesEntity(entityClassFn, void 0, {\n      customEvent: Symbols.REALTIME.TABLE_CHANGE(\n        this.core.ctx.contextName,\n        className,\n      ),\n    });\n  }\n\n\n\n\n  /**\n   * Changes trigger on backend needs to be done manually.. example code:\n   *\n   * ...\n   * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);\n   * // or\n   * Context.Realtime.Server.TrigggerEntityPropertyChanges(myEntityInstance,{ property: 'geolocationX' });\n   * ...\n   */\n  listenChangesEntityObj<T extends BaseEntity>(\n    entity: T,\n    options?: RealtimeModels.ChangeOption,\n  ) {\n    const classFn = ClassHelpers.getClassFnFromObject(entity);\n    const uniqueKey = ClassHelpers.getUniquKey(classFn);\n    return this.listenChangesEntity(classFn, entity[uniqueKey], options);\n  }\n\n\n\n  listenChangesCustomEvent(customEvent: string) {\n    return this.listenChangesEntity(void 0, void 0, {\n      customEvent,\n    });\n  }\n\n\n\n  private getRoomIdFrom(options: RealtimeModels.SubsManagerOpt) {\n    const url = new URL(options.core.ctx.host);\n    return `${this.core.ctx.contextName}:${url.origin}|${options.roomName}|${options.property}|${options.customEvent}`;\n  }\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/realtime/realtime-client.ts"]}

package/browser/esm2022/lib/realtime/realtime-core.mjs

@@ -0,0 +1,54 @@
+import { RealtimeClient } from './realtime-client';
+import { RealtimeServer } from './realtime-server';
+import { RealtimeStrategyIpc, RealtimeStrategyMock, RealtimeStrategySocketIO, } from './realtime-strategy'; /* */
+import { Helpers } from 'tnp-core/browser';
+/**
+ * Realtime class
+ * - mock (when browser-browser)
+ * - sockets (from socket io when backend-browser)
+ * - ipc (when electron is used or between processes)
+ * - webworker (when webworker is used in browser or nodejs)
+ */
+export class RealtimeCore {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.allHttpMethods = [
+            'GET',
+            'POST',
+            'PUT',
+            'DELETE',
+            'PATCH',
+            'OPTIONS',
+            'HEAD',
+        ];
+        this.strategy = this.resolveStrategy();
+        ctx.logFramework &&
+            console.log(`[taon] realtime strategy: ${this.strategy}`);
+        this.client = new RealtimeClient(this);
+        this.server = new RealtimeServer(this);
+    }
+    resolveStrategy() {
+        if (this.ctx.mode === 'backend-frontend(websql)') {
+            return new RealtimeStrategyMock(this.ctx);
+        }
+        if (this.ctx.mode === 'backend-frontend(ipc-electron)') {
+            return new RealtimeStrategyIpc(this.ctx);
+        }
+        return new RealtimeStrategySocketIO(this.ctx);
+    }
+    pathFor(namespace) {
+        const uri = this.ctx.uri;
+        let nsp = namespace ? namespace : '';
+        nsp = nsp === '/' ? '' : nsp;
+        const pathname = uri.pathname !== '/' ? uri.pathname : '';
+        let prefix = `taonContext-`;
+        if (Helpers.isElectron) {
+            prefix = ``;
+        }
+        const href = `${uri.origin}${pathname}/${prefix}${nsp}`;
+        return new URL(href);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/realtime/realtime-core.ts
+//# sourceMappingURL=data:application/json;base64,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