taon 19.0.53 → 19.0.55

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

@@ -1,4 +1,15 @@
 // @ts-nocheck
+import type { Models } from '../models';
 import { BaseInjector } from './base-injector';
+export interface MulterFileUploadResponse {
+    ok: boolean;
+    originalName: string;
+    savedAs: string;
+    savedPath: string;
+    size: number;
+    mimetype: string;
+}
 export declare class BaseController extends BaseInjector {
+    uploadFormDataToServer(formData: FormData): Models.Http.Response<MulterFileUploadResponse[]>;
+    uploadLocalFileToServer(absFilePath: string): Promise<MulterFileUploadResponse[]>;
 }

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

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import express from 'express';
+import * as multer from 'multer';
+import { TaonServerMiddlewareInterceptOptions } from 'ng2-rest/websql';
+import { BaseMiddleware, TaonAddtionalMiddlewareMethodInfo } from './base-middleware';
+/**
+ * Configurable file upload middleware (multer based)
+ */
+export declare class BaseFileUploadMiddleware extends BaseMiddleware {
+    interceptServerMethod({ req, res, next }: TaonServerMiddlewareInterceptOptions, { methodName, expressPath }: TaonAddtionalMiddlewareMethodInfo): Promise<void>;
+    uploadDir(): string;
+    storage(): multer.StorageEngine;
+    upload(): multer.Multer;
+    middleware(): express.RequestHandler;
+}

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

@@ -1,21 +1,39 @@
 // @ts-nocheck
-import type { AxiosRequestConfig } from 'axios';
-import type express from 'express';
+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';
-export interface TaonMiddlewareInterceptOptions {
-    client?: {
-        req: AxiosRequestConfig<unknown>;
-    } | undefined;
-    server?: {
-        req: express.Request;
-        res: express.Response;
-    } | undefined;
-}
 /**
  * TODO
  * - global provider available in all contexts
  * - provider available in own context
  */
 export declare abstract class BaseMiddleware extends BaseInjector {
-    abstract intercept({ server, client, }: TaonMiddlewareInterceptOptions): Promise<void>;
+}
+export interface TaonAddtionalMiddlewareMethodInfo {
+    methodName: string;
+    expressPath: string;
+    httpRequestType: CoreModels.HttpMethod;
+}
+export interface BaseMiddleware {
+    /**
+     * Global interceptor for whole context
+     * backend request
+     */
+    interceptServer({ req, res, next, }: TaonServerMiddlewareInterceptOptions): Promise<void> | void;
+    /**
+     * Global interceptor for whole context
+     * client requests
+     */
+    interceptClient({ req, next, }: TaonClientMiddlewareInterceptOptions): Observable<AxiosResponse<any>>;
+    /**
+     * Specyfic controller method interceptor
+     */
+    interceptServerMethod({ req, res, next }: TaonServerMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType }: TaonAddtionalMiddlewareMethodInfo): Promise<void> | void;
+    /**
+     * Controller method frontned interceptor
+     * TODO not needed ?
+     */
+    interceptClientMethod({ req, next }: TaonClientMiddlewareInterceptOptions, { methodName, expressPath, httpRequestType }: TaonAddtionalMiddlewareMethodInfo): Observable<AxiosResponse<any>>;
 }

package/websql/lib/decorators/classes/controller-config.d.ts

@@ -0,0 +1,10 @@
+// @ts-nocheck
+import { Models } from '../../models';
+import { TaonControllerOptions } from './controller-options';
+export declare class ControllerConfig extends TaonControllerOptions {
+    methods: {
+        [methodName: string]: Models.MethodConfig;
+    };
+    calculatedPath?: string;
+    browserTransformFn?: (entity: any) => any;
+}

package/websql/lib/decorators/classes/controller-decorator.d.ts

@@ -1,16 +1,6 @@
 // @ts-nocheck
-import { Models } from '../../models';
+import type { TaonControllerOptions } from './controller-options';
 /**
  * Controller decorator
  */
-export declare function TaonController(options?: TaonControllerOptions): (constructor: Function) => void;
-export declare class TaonControllerOptions extends Models.DecoratorAbstractOpt {
-    /**
-     * typeorm realtime subscribtion // TODO disabled for now, does not make sense ?s
-     */
-    realtime?: boolean;
-    /**
-     * override default path for controller api
-     */
-    path?: string;
-}
+export declare function TaonController<ControllerClass = any>(options?: TaonControllerOptions<ControllerClass>): (constructor: Function) => void;

package/websql/lib/decorators/classes/controller-options.d.ts

@@ -0,0 +1,12 @@
+// @ts-nocheck
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
+export declare class TaonControllerOptions<ControllerClass = any> extends DecoratorAbstractOpt {
+    /**
+     * typeorm realtime subscribtion // TODO disabled for now, does not make sense ?s
+     */
+    realtime?: boolean;
+    /**
+     * override default path for controller api
+     */
+    path?: string;
+}

package/websql/lib/decorators/classes/entity-decorator.d.ts

@@ -1,11 +1,11 @@
 // @ts-nocheck
 import { Mapping } from 'ng2-rest/websql';
-import { Models } from '../../models';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
 /**
  * Entity decorator
  */
 export declare function TaonEntity<T = any>(options?: TaonEntityOptions<T>): (constructor: Function) => void;
-export declare class TaonEntityOptions<T = any> extends Models.DecoratorAbstractOpt {
+export declare class TaonEntityOptions<T = any> extends DecoratorAbstractOpt {
     /**
      * default unique property is "id"
      * for your entity it may be something else

package/websql/lib/decorators/classes/middleware-decorator.d.ts

@@ -1,8 +1,8 @@
 // @ts-nocheck
-import { Models } from '../../models';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
 /**
  * Provider decorator
  */
 export declare function TaonMiddleware<T = any>(options?: TaonMiddlewareOptions<T>): (constructor: Function) => void;
-export declare class TaonMiddlewareOptions<T = any> extends Models.DecoratorAbstractOpt {
+export declare class TaonMiddlewareOptions<T = any> extends DecoratorAbstractOpt {
 }

package/websql/lib/decorators/classes/migration-decorator.d.ts

@@ -1,8 +1,8 @@
 // @ts-nocheck
-import { Models } from '../../models';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
 /**
  * Migration decorator
  */
 export declare function TaonMigration(options: TaonMigrationOptions): any;
-export declare class TaonMigrationOptions<T = any> extends Models.DecoratorAbstractOpt {
+export declare class TaonMigrationOptions<T = any> extends DecoratorAbstractOpt {
 }

package/websql/lib/decorators/classes/provider-decorator.d.ts

@@ -1,8 +1,8 @@
 // @ts-nocheck
-import { Models } from '../../models';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
 /**
  * Provider decorator
  */
 export declare function TaonProvider<T = any>(options?: TaonProviderOptions<T>): (constructor: Function) => void;
-export declare class TaonProviderOptions<T = any> extends Models.DecoratorAbstractOpt {
+export declare class TaonProviderOptions<T = any> extends DecoratorAbstractOpt {
 }

package/websql/lib/decorators/classes/repository-decorator.d.ts

@@ -1,8 +1,8 @@
 // @ts-nocheck
-import { Models } from '../../models';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
 /**
  * Repository decorator
  */
 export declare function TaonRepository(options: TaonRepositoryOptions): (constructor: Function) => void;
-export declare class TaonRepositoryOptions<T = any> extends Models.DecoratorAbstractOpt {
+export declare class TaonRepositoryOptions<T = any> extends DecoratorAbstractOpt {
 }

package/websql/lib/decorators/classes/subscriber-decorator.d.ts

@@ -1,9 +1,9 @@
 // @ts-nocheck
-import { Models } from '../../models';
+import { DecoratorAbstractOpt } from '../decorator-abstract-opt';
 /**
  * Subscriber decorator
  */
 export declare function TaonSubscriber(options: TaonSubscriberOptions): any;
-export declare class TaonSubscriberOptions<T = any> extends Models.DecoratorAbstractOpt {
+export declare class TaonSubscriberOptions<T = any> extends DecoratorAbstractOpt {
     allowedEvents?: (keyof T)[];
 }

package/websql/lib/decorators/decorator-abstract-opt.d.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+export declare class DecoratorAbstractOpt {
+    className: string;
+}

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

@@ -1,11 +1,13 @@
 // @ts-nocheck
-import { CoreModels } from 'tnp-core/websql';
 import { Models as ModelsNg2Rest } from 'ng2-rest/websql';
+import { CoreModels } from 'tnp-core/websql';
+import { BaseMiddleware } from '../../base-classes/base-middleware';
 export interface TaonHttpDecoratorOptions {
     /**
-     * ! BE CAREFULL
-     * This method is only for very special cases
-     * Path for the method is automatically generated
+     * @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)
      */
     path?: string;
     /**
@@ -14,7 +16,8 @@ export interface TaonHttpDecoratorOptions {
      */
     pathIsGlobal?: boolean;
     overrideContentType?: CoreModels.ContentType;
-    overridResponseType?: ModelsNg2Rest.ResponseTypeAxios;
+    overrideResponseType?: ModelsNg2Rest.ResponseTypeAxios;
+    middlewares?: (typeof BaseMiddleware)[];
 }
 export declare function GET(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function HEAD(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

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

@@ -5,7 +5,6 @@ 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';
-export type { TaonMiddlewareInterceptOptions } from './base-classes/base-middleware';
 import { ContextDbMigrations } from './context-db-migrations';
 import { Models } from './models';
 export declare class EndpointContext {
@@ -141,6 +140,7 @@ export declare class EndpointContext {
      * ipc/udp needs this
      */
     get contextName(): string;
+    get cwd(): string;
     get activeContext(): string | null;
     get appId(): string;
     get publicAssets(): {
@@ -158,7 +158,8 @@ export declare class EndpointContext {
     initControllers(): Promise<void>;
     writeActiveRoutes(): void;
     get middlewares(): Models.MiddlewareType[];
-    private initFrontnedMiddlewares;
+    private initCustomClientMiddlewares;
+    private initCustomBackendMiddlewares;
     private initBackendMiddlewares;
     private initServer;
     /**

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

@@ -1,5 +1,5 @@
 // @ts-nocheck
-import { Models } from '../models';
+import { ControllerConfig } from '../decorators/classes/controller-config';
 export declare namespace ClassHelpers {
     /**
      * TODO - repalce in every place when getting class fn from object
@@ -12,7 +12,11 @@ export declare namespace ClassHelpers {
     const isContextClassObject: (obj: any) => boolean;
     const setName: (target: Function, className: string) => void;
     const hasParentClassWithName: (target: Function, className: string, targets?: any[]) => boolean;
-    const getControllerConfig: (target: Function) => Models.ControllerConfig | undefined;
+    const getControllerConfig: (target: Function) => ControllerConfig | undefined;
+    /**
+     * Express async handler for middleware functions.
+     */
+    const asyncHandler: (fn: any) => (req: any, res: any, next: any) => void;
     const getMethodsNames: (classOrClassInstance: any, allMethodsNames?: any[]) => string[];
-    const getControllerConfigs: (target: Function, configs?: Models.ControllerConfig[], callerTarget?: Function) => Models.RuntimeControllerConfig[];
+    const getControllerConfigs: (target: Function, configs?: ControllerConfig[], callerTarget?: Function) => ControllerConfig[];
 }

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

@@ -1,10 +1,11 @@
 // @ts-nocheck
+import type { ControllerConfig } from '../decorators/classes/controller-config';
 import { Models } from '../models';
 export declare namespace TaonHelpers {
     const fillUpTo: (s: string, nCharacters: number) => string;
     const isGoodPath: (p: string) => boolean;
     const tryTransformParam: (param: any) => any;
-    const getExpressPath: (c: Models.RuntimeControllerConfig, pathOrClassConfig: Models.MethodConfig) => string;
+    const getExpressPath: (c: ControllerConfig, pathOrClassConfig: Models.MethodConfig) => string;
     const defaultType: (value: any) => {};
     const parseJSONwithStringJSONs: (object: Object, waring?: boolean) => Object;
     const isPlainFileOrFolder: (filePath: any) => boolean;

package/websql/lib/index.d.ts

@@ -23,12 +23,13 @@ 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 { TaonAddtionalMiddlewareMethodInfo } from './base-classes/base-middleware';
 export { createContext, TaonContext } from './create-context';
 export { inject } from './inject';
 export { Models } from './models';
 export * from './constants';
 export { ClassHelpers } from './helpers/class-helpers';
-export type { TaonMiddlewareInterceptOptions } from './base-classes/base-middleware';
+export type { TaonClientMiddlewareInterceptOptions, TaonServerMiddlewareInterceptOptions, } from 'ng2-rest/websql';
 export declare namespace Taon {
     export import Response = models.Models.Http.Response;
     export import Http = http.Http;

package/websql/lib/models.d.ts

@@ -1,8 +1,10 @@
 // @ts-nocheck
-import { RequestHandler } from 'express';
+import type { RequestHandler } from 'express';
 import { Response as ExpressResponse, Request as ExpressRequest } from 'express';
 import { Models as ModelsNg2Rest } from 'ng2-rest/websql';
 import { CoreModels } from 'tnp-core/websql';
+import type { BaseMiddleware } from './base-classes/base-middleware';
+import type { TaonHttpDecoratorOptions } from './decorators/http/http-methods-decorators';
 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 {
@@ -206,9 +208,10 @@ export declare namespace Models {
             serverPath: string;
             locationOnDisk: string;
         }[];
-    }
-    class DecoratorAbstractOpt {
-        className: string;
+        /**
+         * by default cwd === process.cwd()
+         */
+        cwd?: string;
     }
     class ParamConfig {
         paramName: string;
@@ -217,14 +220,11 @@ export declare namespace Models {
         defaultType: any;
         expireInSeconds?: number;
     }
-    class MethodConfig {
+    /**
+     * @link './decorators/http/http-methods-decorators.ts' TaonHttpDecoratorOptions
+     */
+    class MethodConfig implements Pick<TaonHttpDecoratorOptions, 'path' | 'middlewares'> {
         methodName: string;
-        /**
-         * @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)
-         */
         global?: boolean;
         /**
          * override default content type
@@ -237,22 +237,10 @@ export declare namespace Models {
         path: string;
         descriptor: PropertyDescriptor;
         type: CoreModels.HttpMethod;
-        requestHandler: any;
         parameters: {
             [paramName: string]: ParamConfig;
         };
-    }
-    class ControllerConfig extends DecoratorAbstractOpt {
-        realtime?: boolean;
-        path: string;
-        uniqueKey?: string;
-        methods: {
-            [methodName: string]: MethodConfig;
-        };
-    }
-    class RuntimeControllerConfig extends ControllerConfig {
-        calculatedPath?: string;
-        browserTransformFn?: (entity: any) => any;
+        middlewares?: (typeof BaseMiddleware)[];
     }
     namespace Http {
         export import Rest = ModelsNg2Rest;
@@ -269,7 +257,11 @@ export declare namespace Models {
         type SyncResponseFunc<T> = (options?: ResponseFuncOpt<T>) => SyncResponse<T>;
         type MixResponse<T> = SyncResponse<T> | ExpressContext<T>;
         interface ClientAction<T> {
-            received?: Rest.PromiseObservableMix<Rest.HttpResponse<T>>;
+            /**
+             * @deprecated use request() mehods instead
+             */
+            readonly received?: Rest.PromiseObservableMix<Rest.HttpResponse<T>>;
+            request?(axiosConfig?: ModelsNg2Rest.Ng2RestAxiosRequestConfig): Rest.PromiseObservableMix<Rest.HttpResponse<T>>;
         }
         interface AsyncResponse<T> {
             (req?: ExpressRequest, res?: ExpressResponse): Promise<SyncResponse<T> | SyncResponseFunc<T>>;

package/websql/package.json

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