taon 19.0.52 → 19.0.54

package/lib/endpoint-context.d.ts

@@ -5,7 +5,6 @@ import type { Application } from 'express';
 import type { Repository } from 'taon-typeorm';
 import { DataSource } from 'taon-typeorm';
 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 {
@@ -65,7 +64,7 @@ export declare class EndpointContext {
     /**
      * Inside docker there is not need for https secure server
      */
-    private isRunningInsideDocker;
+    readonly isRunningInsideDocker: boolean;
     constructor(originalConfig: Models.ContextOptions<any, any, any, any, any, any, any, any>, configFn: (env: any) => Models.ContextOptions<any, any, any, any, any, any, any, any>);
     init(options?: {
         initFromRecrusiveContextResovle?: boolean;
@@ -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/lib/endpoint-context.js

@@ -8,8 +8,9 @@ const bodyParser = require("body-parser"); // @backend
 const cookieParser = require("cookie-parser"); // @backend
 const cors = require("cors"); // @backend
 const electron_1 = require("electron"); // @backend
-const express = require("express"); // @backend
-const fileUpload = require("express-fileupload"); // @backend
+const express = require("express");
+//  multer in taon middleware will do better job than express-fileupload
+// import * as fileUpload from 'express-fileupload'; // @backend
 const expressSession = require("express-session"); // @backend
 const lib_1 = require("json10/lib");
 const lib_2 = require("lodash-walk-object/lib");
@@ -408,7 +409,11 @@ class EndpointContext {
             if (this.mode === 'backend-frontend(tcp+udp)' && !this.config.abstract) {
                 //#region @backend
                 this.expressApp = express();
+                if (process.env.NODE_ENV === 'production') {
+                    this.expressApp.set('trust proxy', 1);
+                }
                 await this.initBackendMiddlewares();
+                await this.initCustomBackendMiddlewares();
                 const shouldStartHttpsSecureServer = this.isHttpServer && !this.isRunningInsideDocker;
                 this.logFramework &&
                     lib_10.Helpers.info(`
@@ -426,7 +431,7 @@ class EndpointContext {
                     this.expressApp.use(asset.serverPath, express.static(asset.locationOnDisk));
                 });
                 //#endregion
-                await this.initFrontnedMiddlewares();
+                await this.initCustomClientMiddlewares();
             }
             //#endregion
             //#region prepare realtime
@@ -613,7 +618,7 @@ class EndpointContext {
                         lib_10.Helpers.log(`Express server (inside docker) started 0.0.0.0:${this.uriPort}`);
                         lib_10.Helpers.log(`[taon][express-server]listening on port: ${this.uriPort}, hostname: ${this.uriPathname},
     address: ${this.uriProtocol}//localhost:${this.uriPort}${this.uriPathname}
-    env: ${this.expressApp.settings.env}
+    ExpressJS mode: ${this.expressApp.settings.env}
     `);
                         resolve(void 0);
                     });
@@ -623,8 +628,8 @@ class EndpointContext {
                     this.serverTcpUdp.listen(Number(this.uriPort), () => {
                         lib_10.Helpers.log(`Express server (inside nodejs app) started on localhost:${this.uriPort}`);
                         lib_10.Helpers.log(`[taon][express-server]listening on port: ${this.uriPort}, hostname: ${this.uriPathname},
-            address: ${this.uriProtocol}//localhost:${this.uriPort}${this.uriPathname}
-            env: ${this.expressApp.settings.env}
+    address: ${this.uriProtocol}//localhost:${this.uriPort}${this.uriPathname}
+    expressJS mode: ${this.expressApp.settings.env}
             `);
                         resolve(void 0);
                     });
@@ -1093,6 +1098,9 @@ class EndpointContext {
         return this.config.contextName;
     }
     //#endregion
+    get cwd() {
+        return this.config.cwd || process.cwd();
+    }
     get activeContext() {
         return this.config.activeContext || null;
     }
@@ -1264,7 +1272,9 @@ class EndpointContext {
         [taon][typeorm] db prepration done.. db initialize=${this.connection?.isInitialized}
 
 
-        `, dataSourceDbConfig, { 'this.connection': !!this.connection });
+        `, 
+                // dataSourceDbConfig,
+                { 'this.connection': !!this.connection });
                 console.log(`Database file location: ${this.connection.options.database}`);
             }
             //     const entityMetadata = getMetadataArgsStorage();
@@ -1295,6 +1305,7 @@ class EndpointContext {
             const configs = class_helpers_1.ClassHelpers.getControllerConfigs(controllerClassFn);
             // console.log(`Class config for ${ClassHelpers.getName(controllerClassFn)}`, configs)
             const classConfig = configs[0];
+            //#region update class calculate path
             const parentscalculatedPath = lib_10._.slice(configs, 1)
                 .reverse()
                 .map(bc => {
@@ -1318,6 +1329,7 @@ class EndpointContext {
                 }, [])
                     .join('/');
             }
+            //#endregion
             // console.log('calculatedPath', classConfig.calculatedPath);
             lib_10._.slice(configs, 1).forEach(bc => {
                 const alreadyIs = classConfig.methods;
@@ -1432,61 +1444,55 @@ class EndpointContext {
     }
     //#endregion
     //#region methods & getters / init middlewares
-    async initFrontnedMiddlewares() {
-        const middlewares = this.getClassesInstancesArrBy(models_1.Models.ClassType.MIDDLEWARE);
-        for (const middleware of middlewares) {
-            const middlewareInstance = middleware;
-            if (lib_10._.isFunction(middlewareInstance.intercept)) {
-                ((instance, contextName, apiPart, uriPathnameOrNothingIfRoot) => {
-                    const interceptorName = `${contextName}-${class_helpers_1.ClassHelpers.getName(instance)}`;
-                    lib_3.Resource.request.interceptors.set(interceptorName, async (req) => {
-                        console.log('request', req);
-                        const url = new url_1.URL(req.url);
-                        if (url.pathname.startsWith(`${uriPathnameOrNothingIfRoot}/${apiPart}/${contextName}/`)) {
-                            await instance.intercept({
-                                client: {
-                                    req,
-                                },
-                            });
-                        }
-                        else {
-                            // console.log('not fit frontend', url.href);
-                        }
-                        return req;
-                    });
-                })(middlewareInstance, this.contextName, constants_1.apiPrefix, this.uriPathnameOrNothingIfRoot);
-            }
-        }
+    async initCustomClientMiddlewares() {
+        const middlewares = this.getClassesInstancesArrBy(models_1.Models.ClassType.MIDDLEWARE)
+            .map(f => f)
+            .filter(f => lib_10._.isFunction(f.interceptClient));
+        middlewares.forEach(instance => {
+            const contextName = this.contextName;
+            const interceptorName = `${contextName}-${class_helpers_1.ClassHelpers.getName(instance)}`;
+            lib_3.Resource.request.interceptors.set(interceptorName, {
+                intercept: ({ req, next }) => {
+                    const url = new url_1.URL(req.url);
+                    if (url.pathname.startsWith(`${this.uriPathnameOrNothingIfRoot}/${constants_1.apiPrefix}/${contextName}/`)) {
+                        // console.log('intercepting', url.pathname, req);
+                        return instance.interceptClient({
+                            req,
+                            next,
+                        });
+                    }
+                    return next.handle(req);
+                },
+            });
+        });
     }
-    async initBackendMiddlewares() {
+    async initCustomBackendMiddlewares() {
         //#region @backend
         const app = this.expressApp;
         const middlewares = this.getClassesInstancesArrBy(models_1.Models.ClassType.MIDDLEWARE);
         for (const middleware of middlewares) {
             const middlewareInstance = middleware;
-            if (lib_10._.isFunction(middlewareInstance.intercept)) {
-                ((instance, contextName, apiPart, uriPathnameOrNothingIfRoot) => {
-                    const asyncHandler = fn => (req, res, next) => {
-                        Promise.resolve(fn(req, res, next)).catch(next);
-                    };
-                    const middlewareFn = asyncHandler(async (req, res, next) => {
-                        if (req.originalUrl.startsWith(`${uriPathnameOrNothingIfRoot}/${apiPart}/${contextName}/`)) {
-                            await instance.intercept({
-                                server: {
-                                    req,
-                                    res,
-                                },
-                            });
-                        }
-                        else {
-                            // console.log('not fit backend', url.href);
-                        }
+            if (lib_10._.isFunction(middlewareInstance.interceptServer)) {
+                const middlewareFn = class_helpers_1.ClassHelpers.asyncHandler(async (req, res, next) => {
+                    if (req.originalUrl.startsWith(`${this.uriPathnameOrNothingIfRoot}/${constants_1.apiPrefix}/${this.contextName}/`)) {
+                        await middlewareInstance.interceptServer({
+                            req,
+                            res,
+                            next,
+                        });
+                    }
+                    else {
                         next();
-                    });
-                    app.use(middlewareFn);
-                })(middlewareInstance, this.contextName, constants_1.apiPrefix, this.uriPathnameOrNothingIfRoot);
+                    }
+                });
+                app.use(middlewareFn);
             }
         }
+        //#endregion
+    }
+    async initBackendMiddlewares() {
+        //#region @backend
+        const app = this.expressApp;
         // if (this.middlewares) {
         //   this.middlewares.forEach(m => {
         //     const [fun, args] = m;
@@ -1496,7 +1502,7 @@ class EndpointContext {
         this.expressApp.get('/helloworld', (req, res) => {
             res.send(`Hello, world from context ${this.contextName}`);
         });
-        app.use(fileUpload());
+        // app.use(fileUpload());
         app.use(bodyParser.urlencoded({ extended: true }));
         app.use(bodyParser.json());
         app.use(methodOverride());
@@ -1576,16 +1582,31 @@ class EndpointContext {
     //#region methods & getters / init methods node
     initServer(
     //#region parameters
-    type, methodConfig, classConfig, expressPath, target) {
+    httpMethodType, methodConfig, classConfig, expressPath, target) {
         //#region resolve variables
-        //#region @websql
-        const requestHandler = methodConfig.requestHandler &&
-            typeof methodConfig.requestHandler === 'function'
-            ? methodConfig.requestHandler
-            : (req, res, next) => {
-                next();
-            };
-        //#endregion
+        const middlewareHandlers = (Array.isArray(methodConfig.middlewares) &&
+            methodConfig.middlewares?.length > 0
+            ? methodConfig.middlewares
+            : [])
+            .map(middlewareClassFun => {
+            const middlewareInstance = this.getInstanceBy(middlewareClassFun);
+            if (middlewareInstance &&
+                lib_10._.isFunction(middlewareInstance.interceptServerMethod)) {
+                const middlewareFn = class_helpers_1.ClassHelpers.asyncHandler(async (req, res, next) => {
+                    await middlewareInstance.interceptServerMethod({
+                        req,
+                        res,
+                        next,
+                    }, {
+                        methodName: methodConfig.methodName,
+                        expressPath,
+                        httpRequestType: methodConfig.type,
+                    });
+                });
+                return middlewareFn;
+            }
+        })
+            .filter(f => !!f);
         // const url = this.uri;
         //#region get result
         const getResult = async (resolvedParams, req, res) => {
@@ -1595,7 +1616,7 @@ class EndpointContext {
              */
             this.getInstanceBy(target), 
             /**
-             * Params for metjod @GET, @PUT etc.
+             * Params for method @GET, @PUT etc.
              */
             resolvedParams);
             let result = await (0, get_response_value_1.getResponseValue)(response, { req, res });
@@ -1623,15 +1644,17 @@ class EndpointContext {
             //#region apply dummy websql express routers
             //#region @websql
             if (lib_10.Helpers.isWebSQL) {
-                if (!this.expressApp[type.toLowerCase()]) {
-                    this.expressApp[type.toLowerCase()] = () => { };
+                if (!this.expressApp[httpMethodType.toLowerCase()]) {
+                    this.expressApp[httpMethodType.toLowerCase()] = () => { };
+                    // TODO add middlewares for WEBSQL and ELECTRON mode
                 }
             }
             //#endregion
             //#endregion
             //#region @backend
-            this.logHttp && console.log(`[${type.toUpperCase()}] ${expressPath} `);
-            this.expressApp[type.toLowerCase()](expressPath, requestHandler, async (req, res) => {
+            this.logHttp &&
+                console.log(`[${httpMethodType.toUpperCase()}] ${expressPath} `);
+            this.expressApp[httpMethodType.toLowerCase()](expressPath, ...middlewareHandlers, async (req, res) => {
                 // console.log(`[${type.toUpperCase()}] ${expressPath} `);
                 //#region process params
                 const args = [];
@@ -1816,10 +1839,31 @@ class EndpointContext {
      */
     async initClient(
     //#region parameters
-    target, type, methodConfig, expressPath) {
+    target, httpRequestType, methodConfig, // Models.Http.Rest.MethodConfig,
+    expressPath) {
         const ctx = this;
+        //#region init middlewares
+        const middlewares = methodConfig.middlewares
+            .map(f => this.getInstanceBy(f))
+            .filter(f => lib_10._.isFunction(f.interceptClientMethod));
+        middlewares.forEach(instance => {
+            lib_3.Resource.request.methodsInterceptors.set(`${methodConfig.type?.toUpperCase()}-${expressPath}`, {
+                intercept: ({ req, next }) => {
+                    return instance.interceptClientMethod({
+                        req,
+                        next,
+                    }, {
+                        methodName: methodConfig.methodName,
+                        expressPath,
+                        httpRequestType: httpRequestType,
+                    });
+                },
+            });
+        });
+        //#endregion
         // : { received: any; /* Rest<any, any>  */ }
-        this.logHttp && console.log(`${type?.toUpperCase()} ${expressPath} `);
+        this.logHttp &&
+            console.log(`${httpRequestType?.toUpperCase()} ${expressPath} `);
         // console.log('INITING', methodConfig); // TODO inject in static
         //#region resolve storage
         // TODO not a good idea
@@ -1873,6 +1917,9 @@ class EndpointContext {
                 received['observable'] = (0, rxjs_1.from)(received);
                 return {
                     received,
+                    request(axiosConfig) {
+                        return received;
+                    },
                 };
             };
             return;
@@ -2024,6 +2071,11 @@ class EndpointContext {
         /* */
         /* */
         /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
         //#endregion
         //#region handle normal request
         target.prototype[methodConfig.methodName] = function (...args) {
@@ -2064,8 +2116,7 @@ class EndpointContext {
             else {
                 rest = endpoints[ctx.uriOrigin][expressPath];
             }
-            const method = type.toLowerCase();
-            const isWithBody = method === 'put' || method === 'post';
+            const method = httpRequestType.toLowerCase();
             const pathPrams = {};
             let queryParams = {};
             let bodyObject = {};
@@ -2163,9 +2214,11 @@ instead
             }
             //#endregion
             const httpResultObj = {
-                received: isWithBody
-                    ? rest.model(pathPrams)[method](bodyObject, [queryParams])
-                    : rest.model(pathPrams)[method]([queryParams]),
+                received: rest.model(pathPrams)[method](bodyObject, [queryParams]),
+                request(axiosConfig) {
+                    return rest
+                        .model(pathPrams)[method](bodyObject, [queryParams], axiosConfig);
+                },
             };
             return httpResultObj;
         };