@jwn-js/common 1.1.47 → 1.3.1

package/index.js

@@ -3,16 +3,18 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var ApiError = require('./ApiError.js');
-var Server = require('./Server-24c15b65.js');
+var Server = require('./Server-77093d28.js');
 var Jwt = require('./Jwt.js');
 var ApiError$1 = require('./ApiError-b517f53a.js');
-var querystring = require('querystring');
 var stream = require('stream');
+var querystring = require('querystring');
 var formidable = require('formidable');
 var path = require('path');
 var fs = require('fs');
 require('dns');
 require('uWebSockets.js');
+var easyAsh = require('easy-ash');
+var xmljs = require('xml-js');
 require('crypto');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -21,6 +23,7 @@ var querystring__default = /*#__PURE__*/_interopDefaultLegacy(querystring);
 var formidable__default = /*#__PURE__*/_interopDefaultLegacy(formidable);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var xmljs__default = /*#__PURE__*/_interopDefaultLegacy(xmljs);
 
 class Memcached {
   constructor(memjs, specialHeaders = { "x-cache": "memcached-js" }, maxKeyLength = 160, debug = 0) {
@@ -105,6 +108,40 @@ function readJson(res, cb, err) {
   res.onAborted(err);
 }
 
+const rawBody = (res, req) => new Promise((resolve, reject) => {
+  readRaw(res, (obj) => {
+    resolve(obj);
+  }, (e) => {
+    reject(new ApiError$1.ApiError({ message: "Can`t parse request", code: 1, statusCode: 404 }));
+  });
+});
+function readRaw(res, cb, err) {
+  let buffer = Buffer.from([]);
+  res.onData((ab, isLast) => {
+    buffer = Buffer.concat([buffer, Buffer.from(ab)]);
+    if (isLast) {
+      cb(buffer);
+    }
+  });
+  res.onAborted(err);
+}
+
+const streamBody = (res, req) => {
+  const err = new ApiError$1.ApiError({ message: "Can`t parse body", code: 1, statusCode: 404 });
+  res.onAborted(() => err);
+  const stream$1 = new stream.PassThrough();
+  stream$1.headers = {};
+  req.forEach((key, val) => stream$1.headers[key] = val);
+  res.onData((chunk, isLast) => {
+    stream$1.write(Buffer.from(Buffer.from(chunk)));
+    stream$1.resume();
+    if (isLast) {
+      stream$1.end();
+    }
+  });
+  return stream$1;
+};
+
 const urlencodedBody = (res, req) => new Promise((resolve, reject) => {
   readBody(res, (obj) => {
     resolve(obj);
@@ -375,10 +412,603 @@ async function staticBody(res, req, base) {
   }
 }
 
+const status = {
+  100: "100 Continue",
+  101: "101 Switching Protocols",
+  200: "200 OK",
+  201: "201 Created",
+  202: "202 Accepted",
+  203: "203 Non-Authoritative Information",
+  204: "No Content",
+  205: "205 Reset Content",
+  206: "206 Partial Content",
+  300: "300 Multiple Choices",
+  301: "301 Moved Permanently",
+  302: "302 Found",
+  303: "303 See Other",
+  304: "304 Not Modified",
+  305: "305 Use Proxy",
+  306: "306 (Unused)",
+  307: "307 Temporary Redirect",
+  400: "400 Bad Request",
+  401: "401 Unauthorized",
+  402: "402 Payment Required",
+  403: "403 Forbidden",
+  404: "404 Not Found",
+  405: "405 Method Not Allowed",
+  406: "406 Not Acceptable",
+  407: "407 Proxy Authentication Required",
+  408: "408 Request Timeout",
+  409: "409 Conflict",
+  410: "410 Gone",
+  411: "411 Length Required",
+  412: "412 Precondition Failed",
+  413: "413 Request Entity Too Large",
+  414: "414 Request-URI Too Long",
+  415: "415 Unsupported Media Type",
+  416: "416 Requested Range Not Satisfiable",
+  417: "417 Expectation Failed",
+  500: "500 Internal Server Error",
+  501: "501 Not Implemented",
+  502: "502 Bad Gateway",
+  503: "503 Service Unavailable",
+  504: "504 Gateway Timeout",
+  505: "505 HTTP Version Not Supported"
+};
+const codeToStatus = (code) => {
+  return status.hasOwnProperty(code) ? status[code] : `${code}`;
+};
+
+class Ssr {
+  constructor(res, req, context, entry) {
+    this.res = res;
+    this.req = req;
+    this.context = context;
+    this.entry = entry;
+  }
+  async request(request = {}) {
+    this.res.onAborted(() => {
+      console.log("Abort is SSR handler");
+    });
+    const url = this.req.getUrl();
+    const extension = getExt(url);
+    if (extensions.includes(extension)) {
+      await staticBody(this.res, this.req, "./dist/client");
+      return;
+    }
+    const contextSsr = {
+      hostname: this.req.getHeader("host"),
+      protocol: this.req.getHeader("x-forwarded-proto") || "http",
+      url: this.req.getUrl(),
+      cookies: Server.cookieParse(this.req.getHeader("cookie")),
+      ip: this.req.getHeader("x-forwarded-for")?.split(/,\s+/)?.[0],
+      memcache: null,
+      statusCode: 200,
+      headers: {},
+      responseHeaders: {
+        "content-type": "text/html; charset=utf-8"
+      }
+    };
+    this.req.forEach((key2, value) => contextSsr.headers[key2] = value);
+    const key = `${contextSsr.protocol}://${contextSsr.hostname}${contextSsr.url}`;
+    let html;
+    const page = await this.context.memcached.getPage(key);
+    if (page) {
+      html = page.data.toString();
+      contextSsr.headers = page.headers;
+    } else {
+      ({ html } = await this.entry(url, {
+        manifest: this.context.manifest,
+        res: this.res,
+        req: this.req,
+        context: contextSsr
+      }));
+      if (contextSsr.statusCode === 200) {
+        await this.context.memcached.setPage(key, contextSsr.headers, html, contextSsr.memcache);
+      }
+    }
+    this.res.writeStatus(codeToStatus(contextSsr.statusCode));
+    Object.keys(contextSsr.headers).map((key2) => this.res.writeHeader(key2, contextSsr.headers[key2]));
+    this.res.end(html);
+  }
+}
+
+const selectControllerParams = async (db, method, name, subaction) => {
+  const row = (await db.poolQuery({ sql: `
+            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
+            FROM app_controllers c
+                LEFT JOIN app_subactions s ON s.app_controllers_id = c.id AND s.name = :subaction
+                LEFT JOIN app_actions a ON a.id = s.app_actions_id
+            WHERE c.name = :name
+        `, namedPlaceholders: true }, { name, subaction }))?.[0];
+  if (!row) {
+    throw new ApiError$1.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Controller ${name} not found is site schema`
+    });
+  }
+  const allowMethods = (row?.action_method || "").split(",").map((method2) => method2.trim());
+  if (row.controller_is_active !== 1) {
+    throw new ApiError$1.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Controller ${name} not active is site schema`
+    });
+  }
+  if (!row.action_id) {
+    throw new ApiError$1.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Action not found is site schema`
+    });
+  }
+  if (row.action_is_active !== 1) {
+    throw new ApiError$1.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Action ${row.action_name} not active is site schema`
+    });
+  }
+  if (!row.subaction_id) {
+    throw new ApiError$1.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Subaction ${subaction} not found is site schema`
+    });
+  }
+  if (row.subaction_is_active !== 1) {
+    throw new ApiError$1.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Subaction ${subaction} not active is site schema`
+    });
+  }
+  if (row.subaction_is_check_method !== 0) {
+    if (row.action_method !== "any" && !allowMethods.includes(method)) {
+      throw new ApiError$1.ApiError({
+        statusCode: 404,
+        code: 11,
+        message: `Controller ${name} action ${row.action_name} allow only ${row.action_method} method`
+      });
+    }
+  }
+  return {
+    controller: {
+      id: +row.controller_id,
+      name: row.controller_name,
+      isActive: !!row.controller_is_active,
+      isSitemap: !!row.controller_is_sitemap
+    },
+    action: {
+      id: +row.action_id,
+      name: row.action_name,
+      isActive: !!row.action_is_active,
+      method: row.action_method
+    },
+    subaction: {
+      id: +row.subaction_id,
+      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
+    }
+  };
+};
+
+class Web {
+  constructor(res, req, context) {
+    this.defaultRequest = {
+      controller: "Index",
+      subaction: "index",
+      lang: "ru"
+    };
+    this.defaultResponse = {
+      statusCode: 200,
+      headers: { "content-type": "application/json" },
+      body: {}
+    };
+    this.res = res;
+    this.req = req;
+    this.context = context;
+  }
+  async request(request = {}) {
+    let response = {};
+    try {
+      this.contextWeb = {
+        config: this.context.config,
+        db: this.context.db,
+        method: this.req.getMethod(),
+        cookies: this.req.cookies,
+        hostname: this.req.getHeader("host"),
+        protocol: this.req.getHeader("x-forwarded-proto") || "http",
+        url: this.req.getUrl(),
+        headers: {}
+      };
+      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 (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) {
+        Object.assign(request, await multipartBody(this.res, this.req));
+      } else if (!["get", "head"].includes(this.contextWeb.method) && type.indexOf("application/x-www-form-urlencoded") !== -1) {
+        Object.assign(request, await urlencodedBody(this.res, this.req));
+      } else if (!["get", "head"].includes(this.contextWeb.method) && (type.indexOf("application/xml") !== -1 || type.indexOf("text/xml") !== -1)) {
+        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) {
+        Object.defineProperty(this.contextWeb, "$stream", {
+          enumerable: false,
+          configurable: false,
+          writable: false,
+          value: await streamBody(this.res, this.req)
+        });
+      } else {
+        Object.defineProperty(this.contextWeb, "$body", {
+          enumerable: false,
+          configurable: false,
+          writable: false,
+          value: await rawBody(this.res, this.req)
+        });
+      }
+      this.route = this.findRoute(request);
+      Object.assign(this.contextWeb, await selectControllerParams(this.contextWeb.db.home, this.contextWeb.method, this.route.name, request.subaction));
+      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 controller = new controllerClass();
+      this.injectContext(controller);
+      const initResponse = await this.initComponent(controller);
+      if (typeof initResponse === "undefined") {
+        if (request.subaction in controller) {
+          response = await controller[request.subaction]();
+        } else {
+          throw new ApiError$1.ApiError({
+            statusCode: 404,
+            code: 13,
+            message: `Method ${request.subaction} not found in  ${request.controller} route`
+          });
+        }
+      } else {
+        response = initResponse;
+      }
+      response = Object.assign({}, this.defaultResponse, response);
+      this.success(response);
+    } catch (e) {
+      this.error(e);
+    }
+  }
+  async importController(request) {
+    let controllerClass = this.route.component.default || this.route.component;
+    if (!easyAsh.isClass(controllerClass)) {
+      controllerClass = (await this.route.component()).default;
+    }
+    if (typeof controllerClass !== "function") {
+      throw new ApiError$1.ApiError({
+        statusCode: 404,
+        code: 12,
+        message: `Class not found for  ${request.controller} 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];
+    if (!route) {
+      throw new ApiError$1.ApiError({
+        statusCode: 404,
+        code: 11,
+        message: `Route ${request.controller} not found`
+      });
+    }
+    return route;
+  }
+  injectContext(obj) {
+    if ("$inject" in obj) {
+      obj.$inject(this.contextWeb);
+    }
+  }
+  async initComponent(obj) {
+    const inits = ["init", ...obj.$inits || []];
+    for (const method of inits) {
+      if (obj[method]) {
+        const out = await obj[method]();
+        if (out) {
+          return out;
+        }
+      }
+    }
+  }
+  success(response) {
+    const status = codeToStatus(response.statusCode || 200);
+    const body = easyAsh.isObject(response.body) ? JSON.stringify(response.body) : response.body;
+    this.res.writeStatus(status);
+    Object.entries(response.headers).map(([key, value]) => this.res.writeHeader(key, value));
+    this.res.end(body);
+  }
+  error(e) {
+    let status = codeToStatus(404), headers = {}, body = e.message;
+    if (e instanceof ApiError$1.ApiError) {
+      const data = { message: e.getMessage() };
+      status = codeToStatus(e.getStatusCode());
+      headers = e.getHeaders();
+      body = easyAsh.isObject(e.getData()) && Object.keys(e.getData()).length > 0 ? JSON.stringify(e.getData()) : JSON.stringify(data);
+    }
+    this.res.writeStatus(status);
+    Object.entries(headers).map(([key, value]) => this.res.writeHeader(key, value));
+    this.res.end(body);
+  }
+}
+
+const config = readConfigSync("./connect.json");
+const mountWithContext = async ($class, $context, request = {}) => {
+  const initComponent = async (obj2) => {
+    let out;
+    if ("init" in obj2) {
+      out = await obj2.init();
+    }
+    return out;
+  };
+  const injectContext = (obj2, $context2) => {
+    if ("$inject" in obj2) {
+      obj2.$inject($context2);
+    }
+  };
+  $context = Object.assign({
+    config,
+    getRequest: () => request,
+    method: "get",
+    ...request.controller && request.subaction && $context.db?.home ? await selectControllerParams($context.db.home, $context.method || "get", request.controller, request.subaction) : {},
+    cookies: {},
+    hostname: config.server?.development?.host,
+    protocol: "http",
+    headers: {}
+  }, $context);
+  const obj = new $class();
+  injectContext(obj, $context);
+  const initResponse = await initComponent(obj);
+  if (initResponse) {
+    throw new ApiError$1.ApiError({
+      statusCode: 404,
+      code: 13,
+      message: `init method response value`
+    });
+  }
+  return obj;
+};
+
+const xmlOptions = { compact: true, ignoreComment: true, spaces: 4 };
+class Controller {
+  setCookieHeader(name, value, options = {}) {
+    return cookieString(name, value, options);
+  }
+  success(data = {}, options) {
+    return {
+      headers: options?.headers || { "content-type": "application/json" },
+      body: {
+        isError: false,
+        data
+      },
+      memcache: options?.memcache || null,
+      statusCode: options?.statusCode || 200
+    };
+  }
+  error(err) {
+    const e = err;
+    const code = e.code ? e.code : 0;
+    const message = e.message ? e.message : "Api request error";
+    const statusCode = e.statusCode ? e.statusCode : 404;
+    const data = e.data ? e.data : {};
+    const response = e.response ? {
+      status: e.response.status,
+      headers: e.response.headers,
+      config: {
+        url: e.response.url,
+        method: e.response.method,
+        params: e.response.params,
+        headers: e.response.headers
+      },
+      data: e.response.data
+    } : {};
+    const headers = Object.assign({ "content-type": "application/json" }, e.headers);
+    return {
+      headers,
+      body: {
+        isError: true,
+        error: message,
+        code,
+        data,
+        stack: process.env.NODE_ENV !== "production" ? e.stack : "",
+        response: process.env.NODE_ENV !== "production" ? response : {}
+      },
+      statusCode
+    };
+  }
+  successXml(data = {}, options) {
+    const defaultXml = {
+      _declaration: {
+        _attributes: {
+          version: "1.0",
+          encoding: "utf-8"
+        }
+      }
+    };
+    const response = this.success(data, options);
+    return {
+      headers: options?.headers || { "content-type": "application/xml" },
+      body: xmljs__default['default'].js2xml(Object.assign(defaultXml, { body: { ...response.body } }), xmlOptions),
+      memcache: response.memcache
+    };
+  }
+  errorXml(err) {
+    const e = err;
+    const defaultXml = {
+      _declaration: {
+        _attributes: {
+          version: "1.0",
+          encoding: "utf-8"
+        }
+      }
+    };
+    const response = this.error(e);
+    const headers = Object.assign({ "content-type": "application/json" }, e.headers);
+    return {
+      headers,
+      body: xmljs__default['default'].js2xml(Object.assign(defaultXml, { body: { ...response.body } }), xmlOptions),
+      statusCode: response.statusCode
+    };
+  }
+  async $create(model, ...args) {
+    const obj = new model(...args);
+    if ("$inject" in obj) {
+      obj.$inject({
+        method: this.$context.method,
+        getRequest: this.$context.getRequest,
+        config: this.$context.config,
+        db: this.$context.db,
+        headers: this.$context.headers,
+        controller: this.$context.controller,
+        action: this.$context.action,
+        subaction: this.$context.subaction
+      });
+    }
+    const inits = ["init", ...obj.$inits || []];
+    for (const method of inits) {
+      if (obj[method]) {
+        await obj[method]();
+      }
+    }
+    return obj;
+  }
+  $inject(context) {
+    this.$context = context;
+  }
+  getContext() {
+    return this.$context;
+  }
+  getRequest() {
+    return this.$context.getRequest();
+  }
+  getBody() {
+    return this.$context["$body"] || Buffer.from("");
+  }
+  getStream() {
+    return this.$context["$stream"] || new stream.PassThrough().end();
+  }
+  getConfig() {
+    return this.$context.config;
+  }
+  getMethod() {
+    return this.$context.method;
+  }
+  getCookies() {
+    return this.$context.cookies;
+  }
+  getHostname() {
+    return this.$context.hostname;
+  }
+  getUrl() {
+    return this.$context.url;
+  }
+  getProtocol() {
+    return this.$context.protocol;
+  }
+  getDb() {
+    return this.$context.db;
+  }
+  getHeaders() {
+    return this.$context.headers;
+  }
+  getController() {
+    return this.$context.controller;
+  }
+  getAction() {
+    return this.$context.action;
+  }
+  getSubaction() {
+    return this.$context.subaction;
+  }
+  getHome() {
+    return this.getDb().home;
+  }
+}
+
+class Model {
+  async $create(model, ...args) {
+    const obj = new model(...args);
+    if ("$inject" in obj) {
+      obj.$inject({
+        method: this.$context.method,
+        getRequest: this.$context.getRequest,
+        config: this.$context.config,
+        db: this.$context.db,
+        headers: this.$context.headers,
+        controller: this.$context.controller,
+        action: this.$context.action,
+        subaction: this.$context.subaction
+      });
+    }
+    if ("init" in obj) {
+      await obj.init();
+    }
+    return obj;
+  }
+  $inject(context) {
+    this.$context = context;
+  }
+  getContext() {
+    return this.$context;
+  }
+  getRequest() {
+    return this.$context.getRequest();
+  }
+  getConfig() {
+    return this.$context.config;
+  }
+  getMethod() {
+    return this.$context.method;
+  }
+  getHeaders() {
+    return this.$context.headers;
+  }
+  getController() {
+    return this.$context.controller;
+  }
+  getAction() {
+    return this.$context.action;
+  }
+  getSubaction() {
+    return this.$context.subaction;
+  }
+}
+
 const helpers = {
   cookieParse: Server.cookieParse,
   cookieString,
   jsonBody,
+  rawBody,
+  streamBody,
   urlencodedBody,
   multipartBody,
   readConfig,
@@ -392,5 +1022,10 @@ exports.ApiError = ApiError.ApiError;
 exports.Server = Server.Server;
 exports.codeToStatus = Server.codeToStatus;
 exports.Jwt = Jwt.Jwt;
+exports.Controller = Controller;
 exports.Memcached = Memcached;
+exports.Model = Model;
+exports.Ssr = Ssr;
+exports.Web = Web;
 exports.helpers = helpers;
+exports.mount = mountWithContext;