taon 19.0.66 → 19.0.68

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

@@ -5,5 +5,12 @@ export declare class BaseClass<CloneT extends BaseClass = any> {
      * taon after class instance creation
      */
     _(): Promise<void>;
-    clone(override?: Partial<CloneT>): CloneT;
+    /**
+     *
+     * @param overrideObjOrFn if object is provided it will override values in cloned object,
+     * if function is provided it will be called with old cloned values and should return
+     * object with values to override
+     * @returns cloned instance of the class
+     */
+    clone(overrideObjOrFn?: Partial<CloneT> | ((oldValues: Partial<CloneT>) => Partial<CloneT>)): CloneT;
 }

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

@@ -1,4 +1,5 @@
 // @ts-nocheck
+import { RestErrorResponseWrapper, HttpResponseError } from 'ng2-rest/websql';
 import type { ContextsEndpointStorage } from '../endpoint-context-storage';
 import type { Models } from '../models';
 import { BaseInjector } from './base-injector';
@@ -13,7 +14,7 @@ export interface MulterFileUploadResponse {
     size: number;
     mimetype: string;
 }
-export declare class BaseController<T = any> extends BaseInjector {
+export declare class BaseController<UPLOAD_FILE_QUERY_PARAMS = {}> extends BaseInjector {
     /**
      * Hook that is called when taon app is inited
      * (all contexts are created and inited)
@@ -21,11 +22,62 @@ export declare class BaseController<T = any> extends BaseInjector {
     afterAllCtxInited(options: {
         ctxStorage: ContextsEndpointStorage;
     }): Promise<void>;
-    uploadFormDataToServer(formData: FormData): Models.Http.Response<MulterFileUploadResponse[]>;
+    uploadFormDataToServer(formData: FormData, queryParams?: UPLOAD_FILE_QUERY_PARAMS): Models.Http.Response<MulterFileUploadResponse[]>;
     /**
      * Hook after file is uploaded
      * through `uploadFormDataToServer` or `uploadLocalFileToServer`
      */
-    protected afterFileUploadAction(file: MulterFileUploadResponse): void | Promise<void>;
-    uploadLocalFileToServer(absFilePath: string, options?: Pick<Models.Http.Rest.Ng2RestAxiosRequestConfig, 'onUploadProgress'>): Promise<MulterFileUploadResponse[]>;
+    protected afterFileUploadAction(file?: MulterFileUploadResponse, queryParams?: UPLOAD_FILE_QUERY_PARAMS): void | Promise<void>;
+    uploadLocalFileToServer(absFilePath: string, options?: Pick<Models.Http.Rest.Ng2RestAxiosRequestConfig, 'onUploadProgress'>, queryParams?: UPLOAD_FILE_QUERY_PARAMS): Promise<MulterFileUploadResponse[]>;
+    /**
+     * Easy way to wait for status change with http (1s default) pooling.
+     *
+     * example (in sub class):
+     * ```ts
+        async check() {
+            await this.waitForProperStatusChange({
+              request: () => this.uploadFormDataToServer(void 0, void 0).request(),
+              statusCheck: resp => resp.body.json[0].ok,
+            });
+          }
+     * ```
+     */
+    _waitForProperStatusChange<T>(options: {
+        actionName: string;
+        /**
+         * Request for pooling
+         */
+        request: (opt?: {
+            /**
+             * optional index number to identify request in logs
+             * (starts from 0 and increments by 1 on each try)
+             */
+            reqIndexNum?: number;
+            httpErrorsCount?: number;
+        }) => ReturnType<Models.Http.Response<T>['request']>;
+        poolingInterval?: number;
+        /**
+         * default infinite tries
+         */
+        maxTries?: number;
+        /**
+         * default infiniti allowed http errors
+         */
+        allowedHttpErrors?: number;
+        /**
+         * condition to be met
+         */
+        statusCheck?: (response: Awaited<ReturnType<typeof options.request>>) => boolean;
+        /**
+         * if return true.. loop will continue
+         * if false .. will exit the loop
+         */
+        loopRequestsOnBackendError?: (opt: {
+            unknownError: Error;
+            unknownHttpError: HttpResponseError<any>;
+            taonError: HttpResponseError<RestErrorResponseWrapper>;
+            reqIndexNum?: number;
+            httpErrorsCount?: number;
+        }) => boolean | Promise<boolean>;
+    }): Promise<void>;
 }

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

@@ -5,10 +5,10 @@ import { BaseRepository } from './base-repository';
 /**
  * Please override property entityClassFn with entity class.
  */
-export declare abstract class BaseCrudController<Entity> extends BaseController {
+export declare abstract class BaseCrudController<Entity, UPLOAD_FILE_QUERY_PARAMS = {}> extends BaseController<UPLOAD_FILE_QUERY_PARAMS> {
     protected db: BaseRepository<Entity>;
     /**
-     * Please provide entity as class propery entityClassFn:
+     * Please provide entity as class property entityClassFn:
      * @returns class function
      *
      */
@@ -21,8 +21,9 @@ export declare abstract class BaseCrudController<Entity> extends BaseController
     updateById(id: number | string, item: Entity): Models.Http.Response<Entity>;
     patchById(id: number | string, item: Entity): Models.Http.Response<Entity>;
     bulkUpdate(items: Entity[]): Models.Http.Response<Entity[]>;
-    deleteById(id: number): Models.Http.Response<Entity>;
+    deleteById(id: number | string): Models.Http.Response<Entity>;
     bulkDelete(ids: (number | string)[]): Models.Http.Response<(number | string | Entity)[]>;
-    create(item: Entity): Models.Http.Response<Entity>;
+    clearTable(): Models.Http.Response<void>;
+    save(item: Entity): Models.Http.Response<Entity>;
     bulkCreate(items: Entity): Models.Http.Response<Entity[]>;
 }

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

@@ -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-repository.d.ts

@@ -61,6 +61,9 @@ export declare abstract class BaseRepository<Entity extends {
     bulkSave(items: Entity[], options?: SaveOptions & {
         reload: false;
     }): Promise<Entity[]>;
+    /**
+     * @deprecated use bulkSave instead
+     */
     bulkCreate(items: Entity[], options?: SaveOptions & {
         reload: false;
     }): Promise<Entity[]>;

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

@@ -17,6 +17,7 @@ export declare class MethodConfig implements Pick<TaonHttpDecoratorOptions, 'pat
      * override default axiso response type
      */
     responseType?: any;
+    overrideExpressSendAsHtml?: boolean;
     path: string;
     descriptor: PropertyDescriptor;
     type: CoreModels.HttpMethod;

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

@@ -1,7 +1,7 @@
 // @ts-nocheck
+import { Models } from 'ng2-rest/websql';
 import * as methods from './http-methods-decorators';
 import * as params from './http-params-decorators';
-import { Models } from 'ng2-rest/websql';
 export declare namespace Http {
     export import GET = methods.GET;
     export import POST = methods.POST;
@@ -9,6 +9,7 @@ export declare namespace Http {
     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;
     namespace Param {
         export import Query = params.Query;

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

@@ -18,21 +18,52 @@ export type TaonMiddlewareFunction = (options: {
 export interface TaonHttpDecoratorOptions {
     /**
      * @deprecated don't use in production - keep stuff encapsulated
-     * path is global in express app
-     * ! BE CAREFUL ! global path IS NOT GLOBAL inside dockerized app
-     *  (/api/contextName is automatically added to global path in docker)
+     * normally path is generated from method name and its params
      */
     path?: string;
     /**
-     * ! BE CAREFULL
      * If true, the path will be global
+     *
+     * ! BE CAREFUL ! global path IS NOT GLOBAL inside dockerized app
+     * (/api/contextName is automatically added to global path in docker)
+     *
+     * @deprecated don't use in production - keep stuff encapsulated
      */
     pathIsGlobal?: boolean;
     overrideContentType?: CoreModels.ContentType;
     overrideResponseType?: ModelsNg2Rest.ResponseTypeAxios;
+    /**
+     * Express will send response as HTML string with proper headers
+     */
+    overrideExpressSendAsHtml?: boolean;
     middlewares?: TaonMiddlewareFunction;
 }
 export declare function GET(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * 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 declare function HTML(pathOrOptions?: Pick<TaonHttpDecoratorOptions, 'path' | 'pathIsGlobal'>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function HEAD(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function POST(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function PUT(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

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

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import type { Server } from 'http';
 import type { NgZone } from '@angular/core';
+import * as express from 'express';
 import type { Application } from 'express';
 import type { Repository } from 'taon-typeorm/websql';
 import { DataSource } from 'taon-typeorm/websql';
@@ -18,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
@@ -68,6 +69,7 @@ export declare class EndpointContext {
     get logHttp(): boolean;
     get logRealtime(): boolean;
     get logFramework(): boolean;
+    get logRoutes(): boolean;
     get logDb(): boolean;
     get logMigrations(): boolean;
     /**
@@ -150,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
@@ -171,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>;
@@ -187,6 +192,7 @@ export declare class EndpointContext {
     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)
      */

package/websql/lib/get-response-value.d.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
-import { Models } from './models';
 import { Response as ExpressResponse, Request as ExpressRequest } from 'express';
+import { Models } from './models';
 export declare const getResponseValue: <T>(response: Models.Http.Response<T>, options?: {
     req: ExpressRequest;
     res: ExpressResponse;

package/websql/lib/helpers/taon-helpers.d.ts

@@ -4,6 +4,7 @@ import { MethodConfig } from '../config/method-config';
 export declare namespace TaonHelpers {
     const fillUpTo: (s: string, nCharacters: number) => string;
     const isGoodPath: (p: string) => boolean;
+    const firstStringOrElemFromArray: (stringOrArrayOfString: string[] | string) => string;
     const tryTransformParam: (param: any) => any;
     const getExpressPath: (c: ControllerConfig, pathOrClassConfig: Partial<MethodConfig>) => string;
     const defaultType: (value: any) => {};

package/websql/lib/index.d.ts

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import 'reflect-metadata';
 import { NgZone } from '@angular/core';
+import { RestErrorResponseWrapper } from 'ng2-rest/websql';
 import * as base from './base-classes/base';
 import * as controllerDecorator from './decorators/classes/controller-decorator';
 import * as entityDecorator from './decorators/classes/entity-decorator';
@@ -23,6 +24,7 @@ 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 { TaonAdditionalMiddlewareMethodInfo } from './base-classes/base-middleware';
 export { createContext, TaonContext } from './create-context';
 export { inject } from './inject';
@@ -34,6 +36,8 @@ 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"> | string) => void;
+    type ResponseHtml = models.Models.Http.Response<string>;
     export import Response = models.Models.Http.Response;
     export import Http = http.Http;
     export import Base = base.Base;

package/websql/lib/models.d.ts

@@ -1,9 +1,11 @@
 // @ts-nocheck
 import type { RequestHandler } from 'express';
 import { Response as ExpressResponse, Request as ExpressRequest } from 'express';
-import { Models as ModelsNg2Rest } from 'ng2-rest/websql';
+import { Models as ModelsNg2Rest, RestResponseWrapper } from 'ng2-rest/websql';
 import { CoreModels } from 'tnp-core/websql';
 import type { EndpointContext } from './endpoint-context';
+export declare class TaonRestResponseWrapper extends RestResponseWrapper {
+}
 export declare namespace Models {
     type FrameworkMode = 'backend-frontend(tcp+udp)' | 'remote-backend(tcp+udp)' | 'backend-frontend(ipc-electron)' | 'backend-frontend(websql-electron)' | 'backend-frontend(websql)';
     enum ClassType {
@@ -83,6 +85,7 @@ export declare namespace Models {
         framework?: boolean;
         db?: boolean;
         migrations?: boolean;
+        routes?: boolean;
     };
     interface ContextOptions<CONTEXTS, CONTROLLERS, ENTITIES, REPOSITORIES, PROVIDERS, SUBSCRIBERS, MIGRATIONS, MIDDLEWARES> {
         appId?: string;
@@ -231,15 +234,6 @@ export declare namespace Models {
             (req?: ExpressRequest, res?: ExpressResponse): Promise<SyncResponse<T> | SyncResponseFunc<T>>;
         }
         type Response<T = string> = AsyncResponse<T> & ClientAction<T>;
-        class Errors {
-            message: string;
-            private code;
-            toString: () => string;
-            private constructor();
-            private static create;
-            static entityNotFound(entity?: Function): Errors;
-            static custom(message: string, code?: ModelsNg2Rest.HttpCode): Errors;
-        }
         interface AuthCallBack {
             (methodReference: Function): RequestHandler;
         }

package/websql/lib/realtime/realtime-client.d.ts

@@ -1,33 +1,37 @@
 // @ts-nocheck
 import { Observable } from 'rxjs';
-import type { BaseEntity } from '../base-classes/base-entity';
 import { RealtimeCore } from './realtime-core';
 import { RealtimeModels } from './realtime.models';
+/**
+ * Client for realtime communication
+ * you can listen to:
+ * - entity changes (any property in table changed)
+ * - entity custom property changes (specific property changed)
+ * - entity table changes (new instance added, instance removed)
+ * - custom events
+ */
 export declare class RealtimeClient {
     private core;
     private subsManagers;
     constructor(core: RealtimeCore);
     private init;
     /**
+     * Usage:
+     * myContext.realtimeClient.listenChangesEntity(myEntityInstance);
+     *
+     *
      * Changes trigger on backend needs to be done manually.. example code:
      *
-     * ...
-     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
+     * myContext.realtimeServer.triggerEntityChanges(myEntityInstance);
      * ...
      */
-    listenChangesEntity(entityClassFn: Function, idOrUniqValue: any, options: RealtimeModels.ChangeOption): Observable<unknown>;
-    listenChangesEntityTable(entityClassFn: Function): Observable<unknown>;
+    listenChangesEntity<RESULT = any>(entityClassFnOrObj: Function | object, options?: RealtimeModels.ChangeOption): Observable<RESULT>;
     /**
-     * Changes trigger on backend needs to be done manually.. example code:
-     *
-     * ...
-     * Context.Realtime.Server.TrigggerEntityChanges(myEntityInstance);
-     * // or
-     * Context.Realtime.Server.TrigggerEntityPropertyChanges(myEntityInstance,{ property: 'geolocationX' });
-     * ...
+     * Listen changes entity table
+     * Example: for pagination, lists update ...
      */
-    listenChangesEntityObj<T extends BaseEntity>(entity: T, options?: RealtimeModels.ChangeOption): Observable<unknown>;
-    listenChangesCustomEvent(customEvent: string): Observable<unknown>;
+    listenChangesEntityTable<RESULT = any>(entityClassFn: Function): Observable<RESULT>;
+    listenChangesCustomEvent<RESULT = any>(customEvent: string): Observable<RESULT>;
     /**
      * Trigger custom event on backend
      * @param customEvent global event name

package/websql/lib/realtime/realtime-server.d.ts

@@ -1,14 +1,39 @@
 // @ts-nocheck
 import { Observable } from 'rxjs';
-import type { BaseEntity } from '../base-classes/base-entity';
 import { RealtimeCore } from './realtime-core';
+/**
+ * Server for realtime communication
+ * you can trigger:
+ * - entity changes (any property in table changed)
+ * - entity custom property changes (specific property changed)
+ * - entity table changes (new instance added, instance removed)
+ * - custom events
+ *
+ * and also listen to:
+ * - custom events from yourself
+ */
 export declare class RealtimeServer {
     private core;
     constructor(core: RealtimeCore);
     private init;
     private triggerChanges;
-    triggerEntityChanges(entityObjOrClass: Function, idToTrigger?: number | string): void;
-    triggerEntityPropertyChanges<ENTITY extends BaseEntity>(entityObjOrClass: new (...args: any[]) => ENTITY, property: keyof ENTITY | (keyof ENTITY)[], idToTrigger?: number | string): void;
+    triggerEntityChanges(entityObjOrClass: Function | object, 
+    /**
+     * value of unique key property of entity instance
+     * (this value is not needed if entityObjOrClass is instance of entity)
+     */
+    idToTrigger?: number | string): void;
+    triggerEntityPropertyChanges(entityObjOrClass: Function | object, 
+    /**
+     * property name or array of property names that changed
+     * for entity instance
+     */
+    property: string | string[], 
+    /**
+     * value of unique key property of entity instance
+     * (this value is not needed if entityObjOrClass is instance of entity)
+     */
+    idToTrigger?: number | string): void;
     triggerEntityTableChanges(entityClassOrInstance: Function | object): void;
     triggerCustomEvent(customEvent: string, dataToPush: any): void;
     /**

package/websql/lib/realtime/realtime.models.d.ts

@@ -7,9 +7,22 @@ export declare namespace RealtimeModels {
         roomName: string;
         property: string;
     };
-    type ChangeOption = {
+    interface ChangeOption {
+        /**
+         * Specify property name to listen changes on that property only;
+         */
         property?: string;
+        /**
+         * Override custom event name to listen
+         */
         customEvent?: string;
-    };
+        /**
+         * Value from entity object.
+         * Key for this value is usually id or unique key
+         * property defined in entity decorator.
+         * TODO @LAST IMPLEMENT unique key support
+         */
+        idOrUniqValue?: any;
+    }
     type EventHandler = (...args: any[]) => void;
 }

package/websql/package.json

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