taon 19.0.67 → 19.0.72

package/websql/lib/base-classes/base-abstract-entity.d.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
-import { BaseEntity } from './base-entity';
-import type { BaseClass } from './base-class';
-export declare abstract class BaseAbstractEntity<CloneT extends BaseClass = any> extends BaseEntity<CloneT> {
+import { TaonBaseEntity } from './base-entity';
+import type { TaonBaseClass } from './base-class';
+export declare abstract class TaonBaseAbstractEntity<CloneT extends TaonBaseClass = any> extends TaonBaseEntity<CloneT> {
     id: string;
     version: number;
 }

package/websql/lib/base-classes/base-class.d.ts

@@ -1,5 +1,5 @@
 // @ts-nocheck
-export declare class BaseClass<CloneT extends BaseClass = any> {
+export declare class TaonBaseClass<CloneT extends TaonBaseClass = any> {
     /**
      * class initialization hook
      * taon after class instance creation

package/websql/lib/base-classes/base-context.d.ts

@@ -1,5 +1,5 @@
 // @ts-nocheck
-declare const BaseContext: {
+declare const TaonBaseContext: {
     readonly contextName: string;
     readonly appId: string;
     cloneAsRemote: (cloneOpt?: {
@@ -18,4 +18,4 @@ declare const BaseContext: {
         readonly server: import("../realtime/realtime-server").RealtimeServer;
     };
 };
-export { BaseContext };
+export { TaonBaseContext };

package/websql/lib/base-classes/base-controller.d.ts

@@ -2,7 +2,7 @@
 import { RestErrorResponseWrapper, HttpResponseError } from 'ng2-rest/websql';
 import type { ContextsEndpointStorage } from '../endpoint-context-storage';
 import type { Models } from '../models';
-import { BaseInjector } from './base-injector';
+import { TaonBaseInjector } from './base-injector';
 export interface MulterFileUploadResponse {
     ok: boolean;
     originalName: string;
@@ -14,7 +14,7 @@ export interface MulterFileUploadResponse {
     size: number;
     mimetype: string;
 }
-export declare class BaseController<UPLOAD_FILE_QUERY_PARAMS = {}> extends BaseInjector {
+export declare class TaonBaseController<UPLOAD_FILE_QUERY_PARAMS = {}> extends TaonBaseInjector {
     /**
      * Hook that is called when taon app is inited
      * (all contexts are created and inited)

package/websql/lib/base-classes/base-crud-controller.d.ts

@@ -1,12 +1,12 @@
 // @ts-nocheck
 import { Models } from '../models';
-import { BaseController } from './base-controller';
-import { BaseRepository } from './base-repository';
+import { TaonBaseController } from './base-controller';
+import { TaonBaseRepository } from './base-repository';
 /**
  * Please override property entityClassFn with entity class.
  */
-export declare abstract class BaseCrudController<Entity, UPLOAD_FILE_QUERY_PARAMS = {}> extends BaseController<UPLOAD_FILE_QUERY_PARAMS> {
-    protected db: BaseRepository<Entity>;
+export declare abstract class TaonBaseCrudController<Entity, UPLOAD_FILE_QUERY_PARAMS = {}> extends TaonBaseController<UPLOAD_FILE_QUERY_PARAMS> {
+    protected db: TaonBaseRepository<Entity>;
     /**
      * Please provide entity as class property entityClassFn:
      * @returns class function

package/websql/lib/base-classes/base-custom-repository.d.ts

@@ -1,4 +1,4 @@
 // @ts-nocheck
-import { BaseInjector } from './base-injector';
-export declare abstract class BaseCustomRepository extends BaseInjector {
+import { TaonBaseInjector } from './base-injector';
+export declare abstract class TaonBaseCustomRepository extends TaonBaseInjector {
 }

package/websql/lib/base-classes/base-entity.d.ts

@@ -1,11 +1,11 @@
 // @ts-nocheck
 import { RelationPath } from 'taon-typeorm/websql';
-import { BaseClass } from './base-class';
-export declare abstract class BaseEntity<
+import { TaonBaseClass } from './base-class';
+export declare abstract class TaonBaseEntity<
 /**
  * type for cloning
  */
-CloneT extends BaseClass = any> extends BaseClass<CloneT> {
+CloneT extends TaonBaseClass = any> extends TaonBaseClass<CloneT> {
     /**
      * simple check if relation is ok
      */

package/websql/lib/base-classes/base-file-upload.middleware.d.ts

@@ -2,11 +2,11 @@
 import express from 'express';
 import * as multer from 'multer';
 import { TaonServerMiddlewareInterceptOptions } from 'ng2-rest/websql';
-import { BaseMiddleware, TaonAdditionalMiddlewareMethodInfo } from './base-middleware';
+import { TaonBaseMiddleware, TaonAdditionalMiddlewareMethodInfo } from './base-middleware';
 /**
  * Configurable file upload middleware (multer based)
  */
-export declare class BaseFileUploadMiddleware extends BaseMiddleware {
+export declare class TaonBaseFileUploadMiddleware extends TaonBaseMiddleware {
     interceptServerMethod({ req, res, next }: TaonServerMiddlewareInterceptOptions, { methodName, expressPath }: TaonAdditionalMiddlewareMethodInfo): Promise<void>;
     uploadDir(): string;
     storage(): multer.StorageEngine;

package/websql/lib/base-classes/base-injector.d.ts

@@ -1,8 +1,8 @@
 // @ts-nocheck
 import { EndpointContext } from '../endpoint-context';
-import { BaseCustomRepository } from './base-custom-repository';
-import type { BaseRepository } from './base-repository';
-export declare class BaseInjector {
+import { TaonBaseCustomRepository } from './base-custom-repository';
+import type { TaonBaseRepository } from './base-repository';
+export declare class TaonBaseInjector {
     /**
      * for proxy purposes
      */
@@ -28,12 +28,12 @@ export declare class BaseInjector {
     /**
      * inject crud repo for entity
      */
-    injectRepo<T>(entityForCrud: new (...args: any[]) => T): BaseRepository<T>;
-    injectCustomRepository<T extends BaseCustomRepository>(cutomRepositoryClass: new (...args: any[]) => T): T;
+    injectRepo<T>(entityForCrud: new (...args: any[]) => T): TaonBaseRepository<T>;
+    injectCustomRepository<T extends TaonBaseCustomRepository>(cutomRepositoryClass: new (...args: any[]) => T): T;
     /**
      * aliast to this.injectRepository()
      */
-    injectCustomRepo<T extends BaseCustomRepository>(cutomRepositoryClass: new (...args: any[]) => T): T;
+    injectCustomRepo<T extends TaonBaseCustomRepository>(cutomRepositoryClass: new (...args: any[]) => T): T;
     /**
      * example usage:
      * ...

package/websql/lib/base-classes/base-middleware.d.ts

@@ -3,20 +3,20 @@ import type { AxiosResponse } from 'axios';
 import { TaonClientMiddlewareInterceptOptions, TaonServerMiddlewareInterceptOptions } from 'ng2-rest/websql';
 import { Observable } from 'rxjs';
 import { CoreModels } from 'tnp-core/websql';
-import { BaseInjector } from './base-injector';
+import { TaonBaseInjector } from './base-injector';
 /**
  * TODO
  * - global provider available in all contexts
  * - provider available in own context
  */
-export declare abstract class BaseMiddleware extends BaseInjector {
+export declare abstract class TaonBaseMiddleware extends TaonBaseInjector {
 }
 export interface TaonAdditionalMiddlewareMethodInfo {
     methodName: string;
     expressPath: string;
     httpRequestType: CoreModels.HttpMethod;
 }
-export interface BaseMiddleware {
+export interface TaonBaseMiddleware {
     /**
      * Global interceptor for whole context
      * backend request
@@ -30,10 +30,10 @@ export interface BaseMiddleware {
     /**
      * Specyfic controller method interceptor
      */
-    interceptServerMethod({ req, res, next }: TaonServerMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType }: TaonAdditionalMiddlewareMethodInfo): Promise<void> | void;
+    interceptServerMethod({ req, res, next }: TaonServerMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType, }: TaonAdditionalMiddlewareMethodInfo): Promise<void> | void;
     /**
      * Controller method frontned interceptor
      * TODO not needed ?
      */
-    interceptClientMethod({ req, next }: TaonClientMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType }: TaonAdditionalMiddlewareMethodInfo): Observable<AxiosResponse<any>>;
+    interceptClientMethod({ req, next }: TaonClientMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType, }: TaonAdditionalMiddlewareMethodInfo): Observable<AxiosResponse<any>>;
 }

package/websql/lib/base-classes/base-migration.d.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 import { MigrationInterface, QueryRunner } from 'taon-typeorm/websql';
-import { BaseInjector } from './base-injector';
-export declare class BaseMigration extends BaseInjector implements MigrationInterface {
+import { TaonBaseInjector } from './base-injector';
+export declare class TaonBaseMigration extends TaonBaseInjector implements MigrationInterface {
     /**
      * by default is READY to run
      */

package/websql/lib/base-classes/base-provider.d.ts

@@ -1,9 +1,9 @@
 // @ts-nocheck
-import { BaseInjector } from './base-injector';
+import { TaonBaseInjector } from './base-injector';
 /**
  * TODO
  * - global provider available in all contexts
  * - provider available in own context
  */
-export declare class BaseProvider extends BaseInjector {
+export declare class TaonBaseProvider extends TaonBaseInjector {
 }

package/websql/lib/base-classes/base-repository.d.ts

@@ -4,10 +4,10 @@ import type { QueryDeepPartialEntity } from 'taon-typeorm/websql';
 import type { UpsertOptions } from 'taon-typeorm/websql';
 import type { DataSource as DataSourceType, QueryRunner, SelectQueryBuilder } from 'taon-typeorm/websql';
 import { MySqlQuerySource } from 'taon-type-sql/websql';
-import { BaseCustomRepository } from './base-custom-repository';
-export declare abstract class BaseRepository<Entity extends {
+import { TaonBaseCustomRepository } from './base-custom-repository';
+export declare abstract class TaonBaseRepository<Entity extends {
     id?: any;
-}> extends BaseCustomRepository {
+}> extends TaonBaseCustomRepository {
     abstract entityClassResolveFn: () => any;
     constructor(__entityClassResolveFn: () => any);
     private __dbQuery;

package/websql/lib/base-classes/base-subscriber-for-entity.d.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 import { EntitySubscriberInterface, RecoverEvent, SoftRemoveEvent, InsertEvent, TransactionStartEvent, TransactionCommitEvent, TransactionRollbackEvent, RemoveEvent, UpdateEvent } from 'taon-typeorm/websql';
-import { BaseInjector } from './base-injector';
-export declare abstract class BaseSubscriberForEntity<Entity = any> extends BaseInjector implements EntitySubscriberInterface {
+import { TaonBaseInjector } from './base-injector';
+export declare abstract class TaonBaseSubscriberForEntity<Entity = any> extends TaonBaseInjector implements EntitySubscriberInterface {
     abstract listenTo(): new (...args: any[]) => Entity;
     /**
      * Called after entity is loaded.

package/websql/lib/base-classes/base.d.ts

@@ -12,18 +12,18 @@ import * as provider from './base-provider';
 import * as repository from './base-repository';
 import * as baseSubscriberEntity from './base-subscriber-for-entity';
 export declare namespace Base {
-    export import Controller = controller.BaseController;
-    export import CrudController = crudController.BaseCrudController;
-    export import Entity = entity.BaseEntity;
-    export import AbstractEntity = abstractEntity.BaseAbstractEntity;
+    export import Controller = controller.TaonBaseController;
+    export import CrudController = crudController.TaonBaseCrudController;
+    export import Entity = entity.TaonBaseEntity;
+    export import AbstractEntity = abstractEntity.TaonBaseAbstractEntity;
     export import AbstractEntityOmitKeys = abstractEntity.AbstractEntityOmitKeys;
-    export import Provider = provider.BaseProvider;
-    export import Class = baseClass.BaseClass;
-    export import Repository = repository.BaseRepository;
-    export import CustomRepository = customRepository.BaseCustomRepository;
-    export import SubscriberForEntity = baseSubscriberEntity.BaseSubscriberForEntity;
-    export import Migration = baseMigration.BaseMigration;
-    export import Middleware = baseMiddleware.BaseMiddleware;
+    export import Provider = provider.TaonBaseProvider;
+    export import Class = baseClass.TaonBaseClass;
+    export import Repository = repository.TaonBaseRepository;
+    export import CustomRepository = customRepository.TaonBaseCustomRepository;
+    export import SubscriberForEntity = baseSubscriberEntity.TaonBaseSubscriberForEntity;
+    export import Migration = baseMigration.TaonBaseMigration;
+    export import Middleware = baseMiddleware.TaonBaseMiddleware;
     export import AngularService = baseService.BaseAngularsService;
     const Context: {
         readonly contextName: string;

package/websql/lib/config/method-config.d.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { CoreModels } from 'tnp-core/websql';
-import type { BaseMiddleware } from '../base-classes/base-middleware';
+import type { TaonBaseMiddleware } from '../base-classes/base-middleware';
 import type { TaonHttpDecoratorOptions, TaonMiddlewareFunction, TaonMiddlewareInheritanceObj } from '../decorators/http/http-methods-decorators';
 import { ParamConfig } from './param-config';
 /**
@@ -36,5 +36,5 @@ export declare class MethodConfig implements Pick<TaonHttpDecoratorOptions, 'pat
      * Middlewares array in proper order and ready to be used in
      * express or in axios interceptors.
      */
-    calculatedMiddlewares: (typeof BaseMiddleware)[];
+    calculatedMiddlewares: (typeof TaonBaseMiddleware)[];
 }

package/websql/lib/decorators/http/http-methods-decorators.d.ts

@@ -1,9 +1,9 @@
 // @ts-nocheck
 import { Models as ModelsNg2Rest } from 'ng2-rest/websql';
 import { CoreModels } from 'tnp-core/websql';
-import { BaseMiddleware } from '../../base-classes/base-middleware';
+import { TaonBaseMiddleware } from '../../base-classes/base-middleware';
 export type TaonMiddlewareInheritanceObj = {
-    [parentMiddlewaresName: string]: typeof BaseMiddleware;
+    [parentMiddlewaresName: string]: typeof TaonBaseMiddleware;
 };
 export type TaonMiddlewareFunction = (options: {
     /**

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

@@ -5,7 +5,7 @@ import * as express from 'express';
 import type { Application } from 'express';
 import type { Repository } from 'taon-typeorm/websql';
 import { DataSource } from 'taon-typeorm/websql';
-import type { BaseInjector } from './base-classes/base-injector';
+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';
@@ -19,12 +19,12 @@ export declare class EndpointContext {
      * -> ONLY remote access from backend or frontend to specific backend
      */
     private readonly cloneOptions;
+    private static ngZone;
+    static initNgZone(ngZone: NgZone): void;
     /**
      * JUST FOR TESTING PURPOSES
      */
     readonly USE_MARIADB_MYSQL_IN_DOCKER: boolean;
-    private static ngZone;
-    static initNgZone(ngZone: NgZone): void;
     disabledRealtime: boolean;
     /**
      * check whether context is inited
@@ -102,7 +102,7 @@ export declare class EndpointContext {
     private getClassesInstancesArrBy;
     inject<T>(ctor: new (...args: any[]) => T, options: {
         localInstance?: boolean;
-        contextClassInstance?: BaseInjector;
+        contextClassInstance?: TaonBaseInjector;
         locaInstanceConstructorArgs?: ConstructorParameters<typeof ctor>;
         parentInstanceThatWillGetInjectedStuff: object;
     }): T;
@@ -152,6 +152,9 @@ export declare class EndpointContext {
      */
     get port(): Number | undefined;
     get isHttpServer(): boolean;
+    /**
+     * Check if context is for remote only
+     */
     get isRemoteHost(): boolean;
     /**
      * ipc/udp needs this
@@ -173,8 +176,8 @@ export declare class EndpointContext {
         locationOnDisk: string;
     }[];
     get isProductionMode(): boolean;
-    get host(): string;
-    get orgin(): string;
+    get host(): string | undefined;
+    get origin(): string | undefined;
     initSubscribers(): Promise<void>;
     initEntities(): Promise<void>;
     destroy(): Promise<void>;

package/websql/lib/index.d.ts

@@ -17,26 +17,26 @@ import * as orm from './orm';
 import * as allSymbols from './symbols';
 export * from './ui';
 export { EndpointContext } from './endpoint-context';
-export { BaseRepository } from './base-classes/base-repository';
-export { BaseCustomRepository } from './base-classes/base-custom-repository';
-export { BaseController } from './base-classes/base-controller';
-export { BaseProvider } from './base-classes/base-provider';
-export { BaseEntity } from './base-classes/base-entity';
-export { BaseContext } from './base-classes/base-context';
-export { BaseMigration } from './base-classes/base-migration';
-export { BaseClass } from './base-classes/base-class';
+export { TaonBaseRepository } from './base-classes/base-repository';
+export { TaonBaseCustomRepository } from './base-classes/base-custom-repository';
+export { TaonBaseController } from './base-classes/base-controller';
+export { TaonBaseProvider } from './base-classes/base-provider';
+export { TaonBaseEntity } from './base-classes/base-entity';
+export { TaonBaseContext } from './base-classes/base-context';
+export { TaonBaseMigration } from './base-classes/base-migration';
+export { TaonBaseClass } from './base-classes/base-class';
 export { TaonAdditionalMiddlewareMethodInfo } from './base-classes/base-middleware';
 export { createContext, TaonContext } from './create-context';
 export { inject } from './inject';
-export { Models } from './models';
-export { BaseFileUploadMiddleware } from './base-classes/base-file-upload.middleware';
+export { Models, BaseTaonClassesNames, TaonTempDatabasesFolder, TaonTempRoutesFolder, } from './models';
+export { TaonBaseFileUploadMiddleware } from './base-classes/base-file-upload.middleware';
 export * from './constants';
 export { MulterFileUploadResponse } from './base-classes/base-controller';
 export { ContextsEndpointStorage } from './endpoint-context-storage';
 export { ClassHelpers } from './helpers/class-helpers';
 export type { TaonClientMiddlewareInterceptOptions, TaonServerMiddlewareInterceptOptions, } from 'ng2-rest/websql';
 export declare namespace Taon {
-    const error: (opt: Pick<RestErrorResponseWrapper, "message" | "status" | "details" | "code">) => void;
+    const error: (opt: Pick<RestErrorResponseWrapper, "message" | "status" | "details" | "code"> | string) => void;
     type ResponseHtml = models.Models.Http.Response<string>;
     export import Response = models.Models.Http.Response;
     export import Http = http.Http;

package/websql/lib/models.d.ts

@@ -6,7 +6,11 @@ import { CoreModels } from 'tnp-core/websql';
 import type { EndpointContext } from './endpoint-context';
 export declare class TaonRestResponseWrapper extends RestResponseWrapper {
 }
+export declare const BaseTaonClassesNames: readonly ["BaseCrudController", "BaseController", "BaseAbstractEntity", "BaseEntity", "BaseContext", "BaseCustomRepository", "BaseFileUploadMiddleware", "BaseMiddleware", "BaseClass", "BaseInjector", "BaseMigration", "BaseProvider", "BaseRepository", "BaseSubscriberForEntity", "BaseCliWorkerController", "PortsController", "PortsContext"];
+export declare const TaonTempDatabasesFolder = "databases";
+export declare const TaonTempRoutesFolder = "routes";
 export declare namespace Models {
+    const DatabasesFolder = "databases";
     type FrameworkMode = 'backend-frontend(tcp+udp)' | 'remote-backend(tcp+udp)' | 'backend-frontend(ipc-electron)' | 'backend-frontend(websql-electron)' | 'backend-frontend(websql)';
     enum ClassType {
         ENTITY = "ENTITY",

package/websql/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon/websql",
-  "version": "19.0.67",
+  "version": "19.0.72",
   "module": "fesm2022/taon.mjs",
   "typings": "index.d.ts",
   "exports": {