@jwn-js/common 2.0.21 → 2.0.24

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,56 @@ 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
       };
+      if (["get", "head"].includes(this.contextWeb.method) && this.contextWeb?.stack?.memcached instanceof Memcached) {
+        const memcached = this.contextWeb.stack.memcached;
+        const cache = await memcached.getPage(this.contextWeb.url);
+        if (cache) {
+          const { data, headers } = cache;
+          this.success({
+            body: data.toString(),
+            headers,
+            statusCode: 200
+          });
+        }
+      }
       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 +1180,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 +1195,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 +1226,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 +1235,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;
@@ -1219,8 +1279,13 @@ class Web {
     }
   }
   success(response) {
-    const status = codeToStatus(response.statusCode || 200);
+    const code = response.statusCode || 200;
+    const status = codeToStatus(code);
     const body = easyAsh.isObject(response.body) ? JSON.stringify(response.body) : response.body;
+    if (["get", "head"].includes(this.contextWeb.method) && code === 200 && response.memcache && this.contextWeb?.stack?.memcached instanceof Memcached) {
+      const memcached = this.contextWeb.stack.memcached;
+      memcached.setPage(this.contextWeb.url, response.headers, body, response.memcache).then();
+    }
     this.res.writeStatus(status);
     Object.entries(response.headers).map(([key, value]) => this.res.writeHeader(key, value));
     this.res.end(body);
@@ -1522,6 +1587,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 +1898,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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jwn-js/common",
   "private": false,
-  "version": "2.0.21",
+  "version": "2.0.24",
   "description": "@jwn-js/common package",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -43,7 +43,7 @@
     "zlib": "^1.0.5"
   },
   "dependencies": {
-    "buildmsql": "^1.3.14",
+    "buildmsql": "^1.3.15",
     "easy-ash": "^1.1.7",
     "formidable": "2",
     "memjs": "^1.3.0",