@jwn-js/common 2.0.20 → 2.0.23

package/index.js

@@ -987,12 +987,13 @@ const selectControllerParams = async (db, method, name, subaction, memcached, me
       isPermission: !!row.subaction_is_permission,
       isCheckMethod: !!row.subaction_is_check_method,
       isLog: !!row.subaction_is_log,
-      isActive: !!row.subaction_is_active
+      isActive: !!row.subaction_is_active,
+      isSync: false
     }
   };
 };
 
-const schemaControllerParams = async (schema, method, name, subaction) => {
+const schemaControllerParams = (schema, method, name, subaction) => {
   let controllerRow = schema.controllers.find((row) => row.name === name);
   if (!controllerRow) {
     throw new ApiError.ApiError({
@@ -1075,7 +1076,8 @@ const schemaControllerParams = async (schema, method, name, subaction) => {
       isPermission: subactionRow.isPermission,
       isCheckMethod: subactionRow.isCheckMethod,
       isLog: subactionRow.isLog,
-      isActive: subactionRow.isActive
+      isActive: subactionRow.isActive,
+      isSync: !!subactionRow.isSync
     },
     action: {
       id: actionRow.id,
@@ -1089,8 +1091,6 @@ const schemaControllerParams = async (schema, method, name, subaction) => {
 class Web {
   constructor(res, req, context) {
     this.defaultRequest = {
-      controller: "Index",
-      subaction: "index",
       lang: "ru"
     };
     this.defaultResponse = {
@@ -1098,14 +1098,19 @@ class Web {
       headers: { "content-type": "application/json" },
       body: {}
     };
+    this.defaultControllerSubaction = {
+      controller: "Index",
+      subaction: "index"
+    };
     this.res = res;
     this.req = req;
     this.context = context;
   }
-  async request(request = {}) {
+  async request(input = {}) {
     let response = {};
     try {
       const query = this.req.getQuery();
+      const request = Object.assign({}, this.defaultRequest, input, querystring__default["default"].parse(this.req.getQuery()));
       this.contextWeb = {
         config: this.context.config,
         db: this.context.db,
@@ -1115,11 +1120,44 @@ class Web {
         protocol: this.req.getHeader("x-forwarded-proto") || "http",
         url: this.req.getUrl() + (query ? `?${query}` : ""),
         headers: {},
-        stack: this.context.stack || {}
+        stack: this.context.stack || {},
+        getRequest: () => request,
+        req: this.req,
+        res: this.res
       };
       this.req.forEach((key, value) => this.contextWeb.headers[key] = value);
       const type = this.contextWeb.headers["content-type"] || "application/json";
-      request = Object.assign({}, this.defaultRequest, request, querystring__default["default"].parse(this.req.getQuery()));
+      if (request.controller && request.subaction && this.context.schema) {
+        this.route = this.findRoute(request.controller);
+        Object.assign(this.contextWeb, schemaControllerParams(this.context.schema, this.contextWeb.method, this.route.name, request.subaction));
+        if (this.contextWeb.subaction.isSync) {
+          if (!["get", "head"].includes(this.contextWeb.method)) {
+            Object.defineProperty(this.contextWeb, "$stream", {
+              enumerable: false,
+              configurable: false,
+              writable: false,
+              value: streamBody(this.res, this.req)
+            });
+          }
+          const controllerClass2 = this.importControllerSync(request.controller);
+          const controller2 = new controllerClass2();
+          this.injectContext(controller2);
+          if (request.subaction in controller2) {
+            response = await controller2[request.subaction]();
+          } else {
+            throw new ApiError.ApiError({
+              statusCode: 404,
+              code: 13,
+              message: `Method ${request.subaction} not found in  ${request.controller} route`
+            });
+          }
+          response = Object.assign({}, this.defaultResponse, response);
+          this.success(response);
+          return;
+        }
+      }
+      request.controller = request.controller || this.defaultControllerSubaction.controller;
+      request.subaction = request.subaction || this.defaultControllerSubaction.subaction;
       if (type.indexOf("application/json") !== -1 || type.indexOf("text/json") !== -1) {
         Object.assign(request, await jsonBody(this.res, this.req));
       } else if (!["get", "head"].includes(this.contextWeb.method) && type.indexOf("multipart/form-data") !== -1) {
@@ -1130,12 +1168,12 @@ class Web {
         const raw = (await rawBody(this.res, this.req)).toString();
         const records = xmljs__default["default"].xml2js(raw, { compact: true, cdataKey: "_value", textKey: "_value" });
         Object.assign(request, records || {});
-      } else if (!["get", "head"].includes(this.contextWeb.method) && type.indexOf("application/octet-stream") !== -1) {
+      } else if (!["get", "head"].includes(this.contextWeb.method) && type.indexOf("stream") !== -1) {
         Object.defineProperty(this.contextWeb, "$stream", {
           enumerable: false,
           configurable: false,
           writable: false,
-          value: await streamBody(this.res, this.req)
+          value: streamBody(this.res, this.req)
         });
       } else {
         Object.defineProperty(this.contextWeb, "$body", {
@@ -1145,16 +1183,15 @@ class Web {
           value: await rawBody(this.res, this.req)
         });
       }
-      this.route = this.findRoute(request);
-      Object.assign(this.contextWeb, this.context.schema ? await schemaControllerParams(this.context.schema, this.contextWeb.method, this.route.name, request.subaction) : await selectControllerParams(this.contextWeb.db.home, this.contextWeb.method, this.route.name, request.subaction, this.context.stack?.memcached, this.context.stack?.memcachedPrefix, this.context.stack?.memcachedExpiry));
+      this.route = this.findRoute(request.controller);
+      Object.assign(this.contextWeb, this.context.schema ? schemaControllerParams(this.context.schema, this.contextWeb.method, this.route.name, request.subaction) : await selectControllerParams(this.contextWeb.db.home, this.contextWeb.method, this.route.name, request.subaction, this.context.stack?.memcached, this.context.stack?.memcachedPrefix, this.context.stack?.memcachedExpiry));
       Object.defineProperty(this.contextWeb, "$route", {
         enumerable: false,
         configurable: false,
         writable: false,
         value: this.route
       });
-      const controllerClass = await this.importController(request);
-      this.contextWeb.getRequest = () => request;
+      const controllerClass = await this.importController(request.controller);
       const controller = new controllerClass();
       this.injectContext(controller);
       const initResponse = await this.initComponent(controller);
@@ -1177,7 +1214,7 @@ class Web {
       this.error(e);
     }
   }
-  async importController(request) {
+  async importController(controllerName) {
     let controllerClass = this.route.component.default || this.route.component;
     if (!easyAsh.isClass(controllerClass)) {
       controllerClass = (await this.route.component()).default;
@@ -1186,18 +1223,29 @@ class Web {
       throw new ApiError.ApiError({
         statusCode: 404,
         code: 12,
-        message: `Class not found for  ${request.controller} route`
+        message: `Class not found for  ${controllerName} route`
       });
     }
     return controllerClass;
   }
-  findRoute(request) {
-    const route = this.context.routes.filter((v) => v.name === request.controller && (v.method === this.contextWeb.method || v.method === "any" || Array.isArray(v.method) && v.method.includes(this.contextWeb.method) || typeof v.method === "undefined"))?.[0];
+  importControllerSync(controllerName) {
+    const controllerClass = this.route.component.default || this.route.component;
+    if (typeof controllerClass !== "function") {
+      throw new ApiError.ApiError({
+        statusCode: 404,
+        code: 12,
+        message: `Class not found for  ${controllerName} route`
+      });
+    }
+    return controllerClass;
+  }
+  findRoute(controllerName) {
+    const route = this.context.routes.filter((v) => v.name === controllerName && (v.method === this.contextWeb.method || v.method === "any" || Array.isArray(v.method) && v.method.includes(this.contextWeb.method) || typeof v.method === "undefined"))?.[0];
     if (!route) {
       throw new ApiError.ApiError({
         statusCode: 404,
         code: 11,
-        message: `Route ${request.controller} not found`
+        message: `Route ${controllerName} not found`
       });
     }
     return route;
@@ -1522,6 +1570,60 @@ class Model {
   }
 }
 
+const selectControllersSchema = async (pool) => {
+  const actions = {};
+  const controllers = {};
+  const rows = await pool.poolQuery(`
+            SELECT c.id AS controller_id, 
+               c.name AS controller_name,
+               c.is_active AS controller_is_active,
+               c.is_sitemap AS controller_is_sitemap,
+               a.id AS action_id,
+               a.name AS action_name,
+               a.is_active AS action_is_active,
+               a.method AS action_method,
+               s.id AS subaction_id,
+               s.name AS subaction_name,
+               s.is_permission AS subaction_is_permission,
+               s.is_check_method AS subaction_is_check_method,
+               s.is_log AS subaction_is_log,
+               s.is_active AS subaction_is_active,
+               s.is_sync AS subaction_is_sync
+            FROM app_controllers c
+                INNER JOIN app_subactions s ON s.app_controllers_id = c.id
+                LEFT JOIN app_actions a ON a.id = s.app_actions_id;
+        `);
+  rows.forEach((row) => {
+    actions[row.action_name] = {
+      id: row.action_id,
+      name: row.action_name,
+      isActive: !!row.action_is_active,
+      method: row.action_method
+    };
+    controllers[row.controller_name] = controllers[row.controller_name] || {
+      id: row.controller_id,
+      name: row.controller_name,
+      isActive: !!row.controller_is_active,
+      isSitemap: !!row.controller_is_sitemap,
+      subactions: []
+    };
+    controllers[row.controller_name].subactions.push({
+      id: row.subaction_id,
+      action: row.action_name,
+      name: row.subaction_name,
+      isPermission: !!row.subaction_is_permission,
+      isCheckMethod: !!row.subaction_is_check_method,
+      isLog: !!row.subaction_is_log,
+      isActive: !!row.subaction_is_active,
+      isSync: !!row.subaction_is_sync
+    });
+  });
+  return {
+    controllers: Object.values(controllers),
+    actions: Object.values(actions)
+  };
+};
+
 const argumentsSubactionsKey = Symbol("arguments");
 const argumentsConnectionsKey = Symbol("connections");
 const responseSubactionsKey = Symbol("response");
@@ -1779,6 +1881,7 @@ exports.mount = mountWithContext;
 exports.pool = pool;
 exports.protocol = protocol;
 exports.request = request;
+exports.selectControllersSchema = selectControllersSchema;
 exports.stream = stream;
 exports.subaction = subaction;
 exports.url = url;

package/jsonBody.d.ts

@@ -1,10 +1,10 @@
 import { HttpResponse, HttpRequest } from 'uWebSockets.js';
 
-/**
- * @description
- * Parser of json requests body
- * @throws {ApiError}
- */
+/**
+ * @description
+ * Parser of json requests body
+ * @throws {ApiError}
+ */
 declare const jsonBody: (res: HttpResponse, req: HttpRequest) => Promise<any>;
 
 export { jsonBody };

package/multipartBody.d.ts

@@ -1,33 +1,33 @@
 import { Options } from 'formidable';
 import { HttpResponse, HttpRequest } from 'uWebSockets.js';
 
-/**
- * @description
- * Parser of form urlencoded requests body
- * @throws {ApiError}
- *
- * formidable1
- *    {
- *       size: 3451,
- *       path: 'C:\\Users\\PROFES~1\\AppData\\Local\\Temp\\upload_fa55df09b0f7fdb8fee94b87b7086573',
- *       name: 'logo.png',
- *       type: 'image/png',
- *       mtime: '2021-12-28T16:21:06.006Z'
- *     }
- *
- *
- * Migration to formidable2
- *   {
- *       size: 3451,
- *       filepath: 'C:\\Users\\PROFES~1\\AppData\\Local\\Temp\\4707bbd7d7f6bb8e59f9f3a00',
- *       newFilename: '4707bbd7d7f6bb8e59f9f3a00',
- *       mimetype: 'image/png',
- *       mtime: '2021-12-28T16:18:14.130Z',
- *       originalFilename: 'logo.png'
- *     }
- *
- *
- */
+/**
+ * @description
+ * Parser of form urlencoded requests body
+ * @throws {ApiError}
+ *
+ * formidable1
+ *    {
+ *       size: 3451,
+ *       path: 'C:\\Users\\PROFES~1\\AppData\\Local\\Temp\\upload_fa55df09b0f7fdb8fee94b87b7086573',
+ *       name: 'logo.png',
+ *       type: 'image/png',
+ *       mtime: '2021-12-28T16:21:06.006Z'
+ *     }
+ *
+ *
+ * Migration to formidable2
+ *   {
+ *       size: 3451,
+ *       filepath: 'C:\\Users\\PROFES~1\\AppData\\Local\\Temp\\4707bbd7d7f6bb8e59f9f3a00',
+ *       newFilename: '4707bbd7d7f6bb8e59f9f3a00',
+ *       mimetype: 'image/png',
+ *       mtime: '2021-12-28T16:18:14.130Z',
+ *       originalFilename: 'logo.png'
+ *     }
+ *
+ *
+ */
 declare const multipartBody: (res: HttpResponse, req: HttpRequest, options?: Options) => Promise<any>;
 
 export { multipartBody };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jwn-js/common",
   "private": false,
-  "version": "2.0.20",
+  "version": "2.0.23",
   "description": "@jwn-js/common package",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -27,7 +27,7 @@
     "@typescript-eslint/eslint-plugin": "^4.23.0",
     "@typescript-eslint/parser": "^4.26.1",
     "chalk": "^4.1.1",
-    "esbuild": "^0.14.8",
+    "esbuild": "^0.14.39",
     "eslint": "^7.26.0",
     "fs-extra": "^10.0.0",
     "jest": "^27.4.5",
@@ -43,7 +43,7 @@
     "zlib": "^1.0.5"
   },
   "dependencies": {
-    "buildmsql": "^1.3.9",
+    "buildmsql": "^1.3.15",
     "easy-ash": "^1.1.7",
     "formidable": "2",
     "memjs": "^1.3.0",

package/readConfig.d.ts

@@ -1,7 +1,7 @@
-/**
- * @description
- * Read connect.json
- */
+/**
+ * @description
+ * Read connect.json
+ */
 declare const readConfig: (jsonfile: string) => Promise<any>;
 
 export { readConfig };

package/readConfigSync.d.ts

@@ -1,7 +1,7 @@
-/**
- * @description
- * Read connect.json
- */
+/**
+ * @description
+ * Read connect.json
+ */
 declare const readConfigSync: (jsonfile: string) => any;
 
 export { readConfigSync };

package/staticBody.d.ts

@@ -1,22 +1,22 @@
 import { HttpResponse, HttpRequest } from 'uWebSockets.js';
 
-declare const exts: Record<string, string>;
-/**
- * approved extensions
- */
-declare const extensions: Array<string>;
-/**
- * Get extension from path
- * @param path
- * @return {string}
- */
-declare const getExt: (path: string) => string;
-/**
- * Reed static files
- * @param req
- * @param res
- * @param base
- */
+declare const exts: Record<string, string>;
+/**
+ * approved extensions
+ */
+declare const extensions: Array<string>;
+/**
+ * Get extension from path
+ * @param path
+ * @return {string}
+ */
+declare const getExt: (path: string) => string;
+/**
+ * Reed static files
+ * @param req
+ * @param res
+ * @param base
+ */
 declare function staticBody(res: HttpResponse, req: HttpRequest, base: string): Promise<void>;
 
 export { extensions, exts, getExt, staticBody };

package/urlencodedBody.d.ts

@@ -1,10 +1,10 @@
 import { HttpResponse, HttpRequest } from 'uWebSockets.js';
 
-/**
- * @description
- * Parser of form urlencoded requests body
- * @throws {ApiError}
- */
+/**
+ * @description
+ * Parser of form urlencoded requests body
+ * @throws {ApiError}
+ */
 declare const urlencodedBody: (res: HttpResponse, req: HttpRequest) => Promise<any>;
 
 export { urlencodedBody };