@jwn-js/common 2.2.1 → 2.2.3

package/index.js

@@ -1,4 +1,242 @@
-"use strict";var h=require("./ApiError.js"),_=require("./Server.js"),g=require("./Jwt-CDdbxwvH.js"),k=require("crypto"),Q=require("util"),v=require("./Memcached.js"),E=require("./jsonBody.js"),$=require("stream"),H=require("./urlencodedBody.js"),R=require("./multipartBody.js"),U=require("./readConfig.js"),V=require("./readConfigSync.js"),P=require("./cookieParse.js"),W=require("./cookieString.js"),y=require("./staticBody.js"),X=require("fs"),B=require("path"),S=require("easy-ash"),z=require("querystring"),C=require("xml-js"),G=require("os");require("reflect-metadata"),require("dns"),require("uWebSockets.js"),require("formidable");function O(o){var t=Object.create(null);return o&&Object.keys(o).forEach(function(e){if(e!=="default"){var s=Object.getOwnPropertyDescriptor(o,e);Object.defineProperty(t,e,s.get?s:{enumerable:!0,get:function(){return o[e]}})}}),t.default=o,Object.freeze(t)}var M=O(X),Y=O(B),Z=O(G);const{subtle:N}=k.webcrypto;class ee{constructor(t,e){this.algorithm="SHA-256",this.secret=t,this.algorithm=e?.algorithm||this.algorithm,this.algorithm=this.algorithm.replace("-","").replace("SHA","SHA-")}async verify(t){if(!t)return!1;const e=t.split(".");return await this.signString(`${e[0]}.${e[1]}`)===e[2]}async sign(t){const e=g.toBase64url({alg:this.algorithm.replace("-","").replace("SHA","HS"),typ:"JWT"}),s=g.toBase64url(t),i=await this.signString(`${e}.${s}`);return`${e}.${s}.${i}`}decode(t){const e=(t||"").split("."),s=g.fromBase64url(e[0]),i=g.fromBase64url(e[1]);return{head:s,body:i}}async signString(t){const e=new Q.TextEncoder,s=await N.importKey("raw",e.encode(this.secret),{name:"HMAC",hash:{name:this.algorithm}},!1,["sign","verify"]);return g.urlEncode(Buffer.from(await N.sign("HMAC",s,e.encode(t))).toString("base64"))}}const te=o=>{const t=(o||"").split("."),e=g.fromBase64url(t[0]),s=g.fromBase64url(t[1]);return{head:e,body:s}},j=o=>new Promise((t,e)=>{se(o,s=>t(s),()=>{e(new h.ApiError({message:"Can`t parse request",code:1,statusCode:404}))})});function se(o,t,e){let s=Buffer.from([]);o.onData((i,n)=>{s=Buffer.concat([s,Buffer.from(i)]),n&&t(s)}),o.onAborted(e)}const A=(o,t,e=!0)=>{o.onAborted(()=>new h.ApiError({message:"Connection aborted",code:1,statusCode:404}));const s=new $.PassThrough;return s.headers={},t.forEach((i,n)=>s.headers[i]=n),o.onData((i,n)=>{s.write(Buffer.from(Buffer.from(i))),e&&s.resume(),n&&s.end()}),s},oe=(o,t={})=>{for(const e of o){const s=Y.resolve(e);Object.assign(t,JSON.parse(M.readFileSync(s).toString()))}return t};class ie{constructor(t,e,s,i){this.res=t,this.req=e,this.context=s,this.entry=i}async request(t={}){this.res.onAborted(()=>{console.log("Abort is SSR handler")});const e=this.req.getQuery(),s=this.req.getUrl()+(e?`?${e}`:""),i=y.getExt(s);if(y.extensions.includes(i)){await y.staticBody(this.res,this.req,"./dist/client");return}const n={hostname:this.req.getHeader("host"),protocol:this.req.getHeader("x-forwarded-proto")||"http",url:this.req.getUrl(),cookies:P.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((c,m)=>n.headers[c]=m);const a=`${n.protocol}://${n.hostname}${n.url}`;let r,u=null;this.context.memcached&&(u=await this.context.memcached.getPage(a)),u?(r=u.data.toString(),n.headers=u.headers):({html:r}=await this.entry(s,{manifest:this.context.manifest,res:this.res,req:this.req,context:n}),n.statusCode===200&&this.context.memcached&&await this.context.memcached.setPage(a,n.headers,r,n.memcache)),this.res.writeStatus(_.codeToStatus(n.statusCode)),Object.keys(n.headers).map(c=>this.res.writeHeader(c,n.headers[c])),this.res.end(r)}}const ne=async(o,t,e)=>(await o.poolQuery({sql:`
+'use strict';
+
+var ApiError = require('./ApiError.js');
+var Server = require('./Server.js');
+var Jwt = require('./Jwt-B4QZ2Ypb.js');
+var crypto = require('crypto');
+var util = require('util');
+var Memcached = require('./Memcached.js');
+var jsonBody = require('./jsonBody.js');
+var stream$1 = require('stream');
+var urlencodedBody = require('./urlencodedBody.js');
+var multipartBody = require('./multipartBody.js');
+var readConfig = require('./readConfig.js');
+var readConfigSync = require('./readConfigSync.js');
+var cookieParse = require('./cookieParse.js');
+var cookieString = require('./cookieString.js');
+var staticBody = require('./staticBody.js');
+var fs = require('fs');
+var path = require('path');
+var easyAsh = require('easy-ash');
+var querystring = require('querystring');
+var xmljs = require('xml-js');
+var os = require('os');
+require('reflect-metadata');
+require('dns');
+require('uWebSockets.js');
+require('formidable');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
+
+const { subtle } = crypto.webcrypto;
+class AsyncJwt {
+  /**
+   * @constructor
+   * @param secret
+   * @param opt addition options
+   */
+  constructor(secret, opt) {
+    this.algorithm = "SHA-256";
+    this.secret = secret;
+    this.algorithm = opt?.algorithm || this.algorithm;
+    this.algorithm = this.algorithm.replace("-", "").replace("SHA", "SHA-");
+  }
+  /**
+   * Verify jwt token
+   * @param jwt token
+   * @returns is token valid
+   */
+  async verify(jwt) {
+    if (!jwt) {
+      return false;
+    }
+    const parts = jwt.split(".");
+    const signature = await this.signString(`${parts[0]}.${parts[1]}`);
+    return signature === parts[2];
+  }
+  /**
+   * Get token
+   * @param data - user data
+   * @returns jwt
+   */
+  async sign(data) {
+    const head = Jwt.toBase64url({
+      alg: this.algorithm.replace("-", "").replace("SHA", "HS"),
+      typ: "JWT"
+    });
+    const body = Jwt.toBase64url(data);
+    const signature = await this.signString(`${head}.${body}`);
+    return `${head}.${body}.${signature}`;
+  }
+  /**
+   * Decode token
+   * @param jwt - jwt token
+   * @returns {head, body}
+   */
+  decode(jwt) {
+    const parts = (jwt || "").split(".");
+    const head = Jwt.fromBase64url(parts[0]);
+    const body = Jwt.fromBase64url(parts[1]);
+    return { head, body };
+  }
+  /**
+   * Sign
+   * @param str input string
+   * @returns base64 sign
+   * @private
+   */
+  async signString(str) {
+    const enc = new util.TextEncoder();
+    const key = await subtle.importKey(
+      "raw",
+      enc.encode(this.secret),
+      {
+        name: "HMAC",
+        hash: {
+          name: this.algorithm
+        }
+      },
+      false,
+      ["sign", "verify"]
+    );
+    return Jwt.urlEncode(Buffer.from(await subtle.sign(
+      "HMAC",
+      key,
+      enc.encode(str)
+    )).toString("base64"));
+  }
+}
+
+const jwtDecode = (jwt) => {
+  const parts = (jwt || "").split(".");
+  const head = Jwt.fromBase64url(parts[0]);
+  const body = Jwt.fromBase64url(parts[1]);
+  return { head, body };
+};
+
+const rawBody = (res) => new Promise((resolve, reject) => {
+  readRaw(res, (obj) => resolve(obj), () => {
+    reject(new ApiError.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)]);
+    isLast && cb(buffer);
+  });
+  res.onAborted(err);
+}
+
+const streamBody = (res, req, resume = true) => {
+  res.onAborted(() => new ApiError.ApiError({ message: "Connection aborted", code: 1, statusCode: 404 }));
+  const stream = new stream$1.PassThrough();
+  stream.headers = {};
+  req.forEach((key, val) => stream.headers[key] = val);
+  res.onData((chunk, isLast) => {
+    stream.write(Buffer.from(Buffer.from(chunk)));
+    resume && stream.resume();
+    isLast && stream.end();
+  });
+  return stream;
+};
+
+const readJsonConfigsSync = (configs, input = {}) => {
+  for (const config of configs) {
+    const filePath = path__namespace.resolve(config);
+    Object.assign(input, JSON.parse(fs__namespace.readFileSync(filePath).toString()));
+  }
+  return input;
+};
+
+class Ssr {
+  /**
+   * @constructor
+   * @param res response
+   * @param req request
+   * @param context params
+   * @param entry - entry point function
+   */
+  constructor(res, req, context, entry) {
+    this.res = res;
+    this.req = req;
+    this.context = context;
+    this.entry = entry;
+  }
+  /**
+   * @param request addition request params
+   */
+  async request(request = {}) {
+    this.res.onAborted(() => {
+      console.log("Abort is SSR handler");
+    });
+    const query = this.req.getQuery();
+    const url = this.req.getUrl() + (query ? `?${query}` : "");
+    const extension = staticBody.getExt(url);
+    if (staticBody.extensions.includes(extension)) {
+      await staticBody.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: cookieParse.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, page = null;
+    if (this.context.memcached) {
+      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 && this.context.memcached) {
+        await this.context.memcached.setPage(key, contextSsr.headers, html, contextSsr.memcache);
+      }
+    }
+    this.res.writeStatus(Server.codeToStatus(contextSsr.statusCode));
+    Object.keys(contextSsr.headers).map((key2) => this.res.writeHeader(key2, contextSsr.headers[key2]));
+    this.res.end(html);
+  }
+}
+
+const selectRouteController = async (db, name, subaction) => {
+  return (await db.poolQuery({ sql: `
             SELECT c.id AS controller_id, 
                c.name AS controller_name,
                c.is_active AS controller_is_active,
@@ -17,7 +255,10 @@
                 INNER JOIN app_subactions s ON s.app_controllers_id = c.id
                 LEFT JOIN app_actions a ON a.id = s.app_actions_id
             WHERE c.name = :name AND s.name = :subaction
-        `,namedPlaceholders:!0},{name:t,subaction:e}))?.[0],re=async o=>(await o.poolQuery(`
+        `, namedPlaceholders: true }, { name, subaction }))?.[0];
+};
+const selectAll = async (db) => {
+  const rows = await db.poolQuery(`
             SELECT c.id AS controller_id, 
                c.name AS controller_name,
                c.is_active AS controller_is_active,
@@ -35,7 +276,113 @@
             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;
-        `)).reduce((t,e)=>(t[`${e.controller_name}::${e.subaction_name}`]=e,t),{}),ae=async(o,t,e,s,i="",n=3600)=>{const a=`${i}::routes::controllers`,r=`${t}::${e}`,u=await s.getValue(a);if(u){const c=JSON.parse(u.toString());return(c||{}).hasOwnProperty(r)?c[r]:void 0}else{const c=await re(o);return await s.setValue(a,Buffer.from(JSON.stringify(c)),n),(c||{}).hasOwnProperty(r)?c[r]:void 0}},D=async(o,t,e,s,i,n="",a=3600)=>{let r;if(i&&i.isClient()&&i.isConnectedServers()?r=await ae(o,e,s,i,n,a):r=await ne(o,e,s),!r)throw new h.ApiError({statusCode:404,code:11,message:`Controller ${e} not found in site schema`});const u=(r?.action_method||"").split(",").map(c=>c.trim());if(r.controller_is_active!==1)throw new h.ApiError({statusCode:404,code:11,message:`Controller ${e} not active in site schema`});if(!r.action_id)throw new h.ApiError({statusCode:404,code:11,message:"Action not found in site schema"});if(r.action_is_active!==1)throw new h.ApiError({statusCode:404,code:11,message:`Action ${r.action_name} not active in site schema`});if(!r.subaction_id)throw new h.ApiError({statusCode:404,code:11,message:`Subaction ${s} not found in site schema`});if(r.subaction_is_active!==1)throw new h.ApiError({statusCode:404,code:11,message:`Subaction ${s} not active in site schema`});if(r.subaction_is_check_method!==0&&r.action_method!=="any"&&!u.includes(t))throw new h.ApiError({statusCode:404,code:11,message:`Controller ${e} action ${r.action_name} allow only ${r.action_method} method`});return{controller:{id:+r.controller_id,name:r.controller_name,isActive:!!r.controller_is_active,isSitemap:!!r.controller_is_sitemap},action:{id:+r.action_id,name:r.action_name,isActive:!!r.action_is_active,method:r.action_method},subaction:{id:+r.subaction_id,name:r.subaction_name,isPermission:!!r.subaction_is_permission,isCheckMethod:!!r.subaction_is_check_method,isLog:!!r.subaction_is_log,isActive:!!r.subaction_is_active,isSync:!1}}},ce=async o=>{const t={},e={};return(await o.poolQuery(`
+        `);
+  return rows.reduce((ac, row) => {
+    ac[`${row.controller_name}::${row.subaction_name}`] = row;
+    return ac;
+  }, {});
+};
+const selectRouteControllerMemcached = async (db, name, subaction, memcached, memcachedPrefix = "", expires = 3600) => {
+  const key = `${memcachedPrefix}::routes::controllers`;
+  const index = `${name}::${subaction}`;
+  const schema = await memcached.getValue(key);
+  if (schema) {
+    const json = JSON.parse(schema.toString());
+    return (json || {}).hasOwnProperty(index) ? json[index] : void 0;
+  } else {
+    const all = await selectAll(db);
+    await memcached.setValue(key, Buffer.from(JSON.stringify(all)), expires);
+    return (all || {}).hasOwnProperty(index) ? all[index] : void 0;
+  }
+};
+const selectControllerParams = async (db, method, name, subaction, memcached, memcachedPrefix = "", expires = 3600) => {
+  let row;
+  if (memcached && memcached.isClient() && memcached.isConnectedServers()) {
+    row = await selectRouteControllerMemcached(db, name, subaction, memcached, memcachedPrefix, expires);
+  } else {
+    row = await selectRouteController(db, name, subaction);
+  }
+  if (!row) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Controller ${name} not found in site schema`
+    });
+  }
+  const allowMethods = (row?.action_method || "").split(",").map((method2) => method2.trim());
+  if (row.controller_is_active !== 1) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Controller ${name} not active in site schema`
+    });
+  }
+  if (!row.action_id) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Action not found in site schema`
+    });
+  }
+  if (row.action_is_active !== 1) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Action ${row.action_name} not active in site schema`
+    });
+  }
+  if (!row.subaction_id) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Subaction ${subaction} not found in site schema`
+    });
+  }
+  if (row.subaction_is_active !== 1) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Subaction ${subaction} not active in site schema`
+    });
+  }
+  if (row.subaction_is_check_method !== 0) {
+    if (row.action_method !== "any" && !allowMethods.includes(method)) {
+      throw new ApiError.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,
+      isSync: false
+    }
+  };
+};
+
+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,
@@ -54,4 +401,1126 @@
             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;
-        `)).forEach(s=>{t[s.action_name]={id:s.action_id,name:s.action_name,isActive:!!s.action_is_active,method:s.action_method},e[s.controller_name]=e[s.controller_name]||{id:s.controller_id,name:s.controller_name,isActive:!!s.controller_is_active,isSitemap:!!s.controller_is_sitemap,subactions:[]},e[s.controller_name].subactions.push({id:s.subaction_id,action:s.action_name,name:s.subaction_name,isPermission:!!s.subaction_is_permission,isCheckMethod:!!s.subaction_is_check_method,isLog:!!s.subaction_is_log,isActive:!!s.subaction_is_active,isSync:!!s.subaction_is_sync})}),{controllers:Object.values(e),actions:Object.values(t)}},J=(o,t,e,s)=>{let i=o.controllers.find(u=>u.name===e);if(!i)throw new h.ApiError({statusCode:404,code:11,message:`Controller ${e} not found is site schema`});if(i=Object.assign({isActive:!0,isSitemap:!1},i),!i.isActive)throw new h.ApiError({statusCode:404,code:11,message:`Controller ${e} not active is site schema`});let n=i.subactions.find(u=>u.name===s);if(!n)throw new h.ApiError({statusCode:404,code:11,message:`Subaction ${s} not found is site schema`});if(n=Object.assign({isPermission:!1,isCheckMethod:!1,isLog:!1,isActive:!0},n),!n.isActive)throw new h.ApiError({statusCode:404,code:11,message:`Subaction ${s} not active is site schema`});let a=o.actions.find(u=>u.name===n.action);if(!a)throw new h.ApiError({statusCode:404,code:11,message:"Action not found is site schema"});if(a=Object.assign({isActive:!0,method:"any"},a),!a.isActive)throw new h.ApiError({statusCode:404,code:11,message:`Action ${a.name} not active is site schema`});const r=(a?.method||"").split(",").map(u=>u.trim());if(n.isCheckMethod&&a.method!=="any"&&!r.includes(t))throw new h.ApiError({statusCode:404,code:11,message:`Controller ${e} action ${a.name} allow only ${a.method} method`});return{controller:{id:i.id,name:i.name,isActive:i.isActive,isSitemap:i.isSitemap},subaction:{id:n.id,name:n.name,isPermission:n.isPermission,isCheckMethod:n.isCheckMethod,isLog:n.isLog,isActive:n.isActive,isSync:!!n.isSync},action:{id:a.id,name:a.name,isActive:a.isActive,method:a.method}}};class he{constructor(t,e,s){this.defaultRequest={lang:"ru"},this.defaultResponse={statusCode:200,headers:{"content-type":"application/json"},body:{}},this.defaultControllerSubaction={controller:"Index",subaction:"index"},this.res=t,this.req=e,this.res.onAborted(()=>new h.ApiError({message:"The connection was close",code:1,statusCode:404})),this.context=s}setDefaultRequest(t){return Object.assign(this.defaultRequest,t),this}async request(t={}){let e={};try{const s=this.req.getQuery(),i=Object.assign({},this.defaultRequest,t,z.parse(this.req.getQuery()));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()+(s?`?${s}`:""),headers:{},stack:this.context.stack||{},getRequest:()=>i},this.memcachedKey=`${this.contextWeb.protocol}://${this.contextWeb.hostname}${this.contextWeb.url}`,this.req.forEach((c,m)=>this.contextWeb.headers[c]=m);const n=this.contextWeb.headers["content-type"]||"application/json";if(i.controller&&i.subaction&&this.context.schema&&(this.route=this.findRoute(i.controller),Object.defineProperty(this.contextWeb,"$route",{enumerable:!1,configurable:!1,writable:!1,value:this.route}),Object.assign(this.contextWeb,J(this.context.schema,this.contextWeb.method,this.route.name,i.subaction)),this.contextWeb.subaction.isSync)){["get","head"].includes(this.contextWeb.method)||Object.defineProperty(this.contextWeb,"$stream",{enumerable:!1,configurable:!1,writable:!1,value:A(this.res,this.req,!1)});const c=this.importControllerSync(i.controller),m=new c;if(this.injectContext(m),i.subaction in m)e=await m[i.subaction]();else throw new h.ApiError({statusCode:404,code:13,message:`Method ${i.subaction} not found in  ${i.controller} route`});e=Object.assign({},this.defaultResponse,e),this.success(e);return}if(["get","head"].includes(this.contextWeb.method)&&this.contextWeb?.stack?.memcached instanceof v.Memcached){const c=this.contextWeb.stack.memcached;if(c.isConnectedServers()){const m=await c.getPage(this.memcachedKey);if(m){const{data:b,headers:x}=m;this.success({body:b.toString(),headers:x,statusCode:200})}}}if(i.controller=i.controller||this.defaultControllerSubaction.controller,i.subaction=i.subaction||this.defaultControllerSubaction.subaction,!["get","head"].includes(this.contextWeb.method))if(n.indexOf("application/json")!==-1||n.indexOf("text/json")!==-1)Object.assign(i,await E.jsonBody(this.res));else if(n.indexOf("multipart/form-data")!==-1)Object.assign(i,await R.multipartBody(this.res,this.req)),Object.defineProperty(this.contextWeb,"$files",{enumerable:!1,configurable:!1,writable:!1,value:i.files});else if(n.indexOf("application/x-www-form-urlencoded")!==-1)Object.assign(i,await H.urlencodedBody(this.res));else if(n.indexOf("application/xml")!==-1||n.indexOf("text/xml")!==-1){const c=(await j(this.res)).toString(),m=C.xml2js(c,{compact:!0,cdataKey:"_value",textKey:"_value"});Object.assign(i,m||{})}else n.indexOf("stream")!==-1?Object.defineProperty(this.contextWeb,"$stream",{enumerable:!1,configurable:!1,writable:!1,value:A(this.res,this.req,!1)}):n.indexOf("binary")!==-1?await new Promise(c=>{const m=A(this.res,this.req),b=Z.tmpdir(),x="./body_"+k.randomBytes(32).toString("hex"),d=B.resolve(b,x),p=M.createWriteStream(d);m.pipe(p),Object.defineProperty(this.contextWeb,"$files",{enumerable:!1,configurable:!1,writable:!1,value:{body:{path:d}}}),m.on("end",()=>c(!0))}):Object.defineProperty(this.contextWeb,"$body",{enumerable:!1,configurable:!1,writable:!1,value:await j(this.res)});this.route=this.findRoute(i.controller),Object.assign(this.contextWeb,this.context.schema?J(this.context.schema,this.contextWeb.method,this.route.name,i.subaction):await D(this.contextWeb.db.home,this.contextWeb.method,this.route.name,i.subaction,this.context.stack?.memcached,this.context.stack?.memcachedPrefix,this.context.stack?.memcachedExpiry)),Object.defineProperty(this.contextWeb,"$route",{enumerable:!1,configurable:!1,writable:!1,value:this.route});const a=await this.importController(i.controller),r=new a;this.injectContext(r);const u=await this.initComponent(r);if(typeof u>"u")if(i.subaction in r)e=await r[i.subaction]();else throw new h.ApiError({statusCode:404,code:13,message:`Method ${i.subaction} not found in  ${i.controller} route`});else e=u;e=Object.assign({},this.defaultResponse,e),this.success(e)}catch(s){this.error(s)}}async importController(t){let e=this.route.component.default||this.route.component;if(S.isClass(e)||(e=(await this.route.component()).default),typeof e!="function")throw new h.ApiError({statusCode:404,code:12,message:`Class not found for  ${t} route`});return e}importControllerSync(t){const e=this.route.component.default||this.route.component;if(typeof e!="function")throw new h.ApiError({statusCode:404,code:12,message:`Class not found for  ${t} route`});return e}findRoute(t){const e=this.context.routes.filter(s=>s.name===t&&(s.method===this.contextWeb.method||s.method==="any"||Array.isArray(s.method)&&s.method.includes(this.contextWeb.method)||typeof s.method>"u"))?.[0];if(!e)throw new h.ApiError({statusCode:404,code:11,message:`Route ${t} not found`});return e}injectContext(t){"$inject"in t&&t.$inject(this.contextWeb)}async initComponent(t){const e=[...new Set(["init",...t.$inits||[]])];for(const s of e)if(t[s]){const i=await t[s]();if(i)return i}}success(t){const e=t.body instanceof $.Stream,s=t.statusCode||200,i=_.codeToStatus(s),n=!e&&S.isObject(t.body)?JSON.stringify(t.body):t.body;!e&&["get","head"].includes(this.contextWeb.method)&&s===200&&t.memcache&&this.contextWeb?.stack?.memcached instanceof v.Memcached&&this.contextWeb.stack.memcached.setPage(this.memcachedKey,t.headers,n,t.memcache).then(),e?this.res.cork(()=>{this.res.writeStatus(i),this.writeHeaders(t.headers),n.on("data",a=>{this.res.write(a)}).on("end",()=>{this.res.end()})}):this.res.cork(()=>{this.res.writeStatus(i),this.writeHeaders(t.headers),this.res.end(n)})}error(t){const e=t instanceof h.ApiError&&t.getData()instanceof $.Stream;let s=_.codeToStatus(404),i=this.defaultResponse.headers,n=t.message;if(t instanceof h.ApiError){const a={isError:!0,code:t.getCode(),error:t.getMessage()};s=_.codeToStatus(t.getStatusCode()),i=t.getHeaders()||this.defaultResponse.headers,e?n=t.getData():n=S.isObject(t.getData())&&Object.keys(t.getData()).length>0?JSON.stringify(t.getData()):JSON.stringify(a)}e?this.res.cork(()=>{this.res.writeStatus(s),this.writeHeaders(i),n.on("data",a=>{this.res.write(a)}).on("end",()=>{this.res.end()})}):this.res.cork(()=>{this.res.writeStatus(s),this.writeHeaders(i),this.res.end(n)})}writeHeaders(t){Object.entries(t).forEach(([e,s])=>{Array.isArray(s)?s.forEach(i=>this.res.writeHeader(e,i)):this.res.writeHeader(e,s)})}}const ue=async(o,t,e={})=>{const s=async a=>{let r;return"init"in a&&(r=await a.init()),r},i=(a,r)=>{"$inject"in a&&a.$inject(r)};t=Object.assign({config:{},getRequest:()=>e,method:"get",...e.controller&&e.subaction&&t.db?.home?await D(t.db.home,t.method||"get",e.controller,e.subaction):{},cookies:{},hostname:t.config?.server?.development?.host,protocol:"http",headers:{}},t);const n=new o;if(i(n,t),await s(n))throw new h.ApiError({statusCode:404,code:13,message:"init method response value"});return n},T={compact:!0,ignoreComment:!0,spaces:4};class de{constructor(){this.responseHeaders={}}setCookieHeader(t,e,s={}){return W.cookieString(t,e,s)}success(t={},e){return{headers:Object.assign({"content-type":"application/json"},this.responseHeaders,e?.headers||{}),body:{isError:!1,data:t},memcache:e?.memcache||null,statusCode:e?.statusCode||200}}error(t){const e=t,s=e.code?e.code:0,i=e.message?e.message:"Api request error",n=e.statusCode?e.statusCode:404,a=e.data?e.data:{},r=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}:{};return{headers:Object.assign({"content-type":"application/json"},e.headers),body:{isError:!0,error:i,code:s,data:a,stack:process.env.NODE_ENV!=="production"?e.stack:"",response:process.env.NODE_ENV!=="production"?r:{}},statusCode:n}}successXml(t={},e){const s={_declaration:{_attributes:{version:"1.0",encoding:"utf-8"}}},i=this.success(t,e);return{headers:Object.assign({"content-type":"application/xml"},this.responseHeaders,e?.headers||{}),body:C.js2xml(Object.assign(s,{body:{...i.body}}),T),memcache:i.memcache}}errorXml(t){const e=t,s={_declaration:{_attributes:{version:"1.0",encoding:"utf-8"}}},i=this.error(e);return{headers:Object.assign({"content-type":"application/json"},e.headers),body:C.js2xml(Object.assign(s,{body:{...i.body}}),T),statusCode:i.statusCode}}async $create(t,...e){const s=new t(...e);"$inject"in s&&s.$inject({method:this.$context.method,getRequest:this.$context.getRequest,config:this.$context.config,db:this.$context.db,stack:this.$context.stack,headers:this.$context.headers,cookies:this.$context.cookies,controller:this.$context.controller,action:this.$context.action,subaction:this.$context.subaction,setResponseHeader:(n,a)=>this.setResponseHeader(n,a),setCookieHeader:this.setCookieHeader});const i=["init",...s.$inits||[]];for(const n of i)s[n]&&await s[n]();return s}async $createAll(t){return Promise.all(t.map(e=>this.$create(...e)))}$inject(t){this.$context=t}getContext(){return this.$context}getRequest(){return this.$context.getRequest()}getBody(){return this.$context.$body||Buffer.from("")}getFiles(){return this.$context.$files||{}}getStream(){return this.$context.$stream||new $.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}getPool(t="home"){return this.getDb()[t]}getStack(){return this.$context.stack}setResponseHeader(t,e){this.responseHeaders.hasOwnProperty(t)?(this.responseHeaders[t]=Array.isArray(this.responseHeaders[t])?this.responseHeaders[t]:[this.responseHeaders[t]],this.responseHeaders[t].push(e)):this.responseHeaders[t]=e}}class le{async $create(t,...e){const s=new t(...e);return"$inject"in s&&s.$inject({method:this.$context.method,getRequest:this.$context.getRequest,config:this.$context.config,db:this.$context.db,stack:this.$context.stack,headers:this.$context.headers,cookies:this.$context.cookies,controller:this.$context.controller,action:this.$context.action,subaction:this.$context.subaction,setResponseHeader:this.$context.setResponseHeader,setCookieHeader:this.$context.setCookieHeader}),"init"in s&&await s.init(),s}async $createAll(t){return Promise.all(t.map(e=>this.$create(...e)))}$inject(t){this.$context=t}getContext(){return this.$context}getRequest(){return this.$context.getRequest()}getConfig(){return this.$context.config}getMethod(){return this.$context.method}getHeaders(){return this.$context.headers}getCookies(){return this.$context.cookies}getController(){return this.$context.controller}getAction(){return this.$context.action}getSubaction(){return this.$context.subaction}getDb(){return this.$context.db}getHome(){return this.$context.db.home}getPool(t="home"){return this.getDb()[t]}getStack(){return this.$context.stack}setResponseHeader(t,e){return this.$context.setResponseHeader(t,e)}setCookieHeader(t,e,s={}){return this.$context.setCookieHeader(t,e,s)}}const f=Symbol("arguments"),I=Symbol("connections"),q=Symbol("response"),L=Symbol("init"),F=Symbol("logger"),me=o=>o.charAt(0).toUpperCase()+o.slice(1);function fe(o,t={}){const e=Reflect.ownKeys(o),s=Reflect.ownKeys(t),i=Symbol("isa");function n(a){for(const r of e)Object.defineProperty(a.prototype,r,{value:o[r]});return Object.defineProperty(a.prototype,i,{value:!0}),a}for(const a of s)Object.defineProperty(n,a,{value:t[a],enumerable:t.propertyIsEnumerable(a)});return Object.defineProperty(n,Symbol.hasInstance,{value:a=>!!a[i]}),n}const l=(o,t,e,s,i,n)=>{const a=Reflect.getOwnMetadata(o,t,e)||{};a[s]={type:i,params:n},Reflect.defineMetadata(o,a,t,e)};function pe(){return function(o,t,e){l(f,o,t,e,"request")}}function be(){return function(o,t,e){l(f,o,t,e,"context")}}function ge(){return function(o,t,e){l(f,o,t,e,"config")}}function _e(){return function(o,t,e){l(f,o,t,e,"method")}}function ye(){return function(o,t,e){l(f,o,t,e,"cookies")}}function xe(){return function(o,t,e){l(f,o,t,e,"hostname")}}function we(){return function(o,t,e){l(f,o,t,e,"url")}}function $e(){return function(o,t,e){l(f,o,t,e,"protocol")}}function Se(){return function(o,t,e){l(f,o,t,e,"db")}}function Ae(){return function(o,t,e){l(f,o,t,e,"headers")}}function ve(){return function(o,t,e){l(f,o,t,e,"controller")}}function Ce(){return function(o,t,e){l(f,o,t,e,"action")}}function Oe(){return function(o,t,e){l(f,o,t,e,"subaction")}}function je(){return function(o,t,e){l(f,o,t,e,"body")}}function qe(){return function(o,t,e){l(f,o,t,e,"stream")}}function ke(){return function(o,t,e){l(f,o,t,e,"home")}}function Ee(o="home"){return function(t,e,s){l(f,t,e,s,"pool",o)}}function He(o="home"){return function(t,e,s){l(I,t,e,s,"connection",o)}}function Re(o={}){return function(t,e,s){l(q,t,e,0,"json",o)}}function Pe(o={}){return function(t,e,s){l(q,t,e,0,"xml",o)}}function We(o){return function(t,e,s){l(F,t,e,o,"logger",o)}}function Be(o){return function(t,e,s){const i={format:"json"},n=s.value;s.value=async function(){o&&Object.assign(i,await o.apply(this)||{});const a=[],r=[],u=Reflect.getOwnMetadata(f,t,e)||{},c=Reflect.getOwnMetadata(I,t,e)||{},m=Reflect.getOwnMetadata(F,t,e)||{},b=Reflect.getOwnMetadata(q,t,e)?.[0]||{type:"json",params:{}},x=Reflect.getOwnMetadata(L,t,e)?.[0]||{type:"",params:{}};for(const d in u){if(!u.hasOwnProperty(d))continue;const p=`get${me(u[d].type)}`;a[+d]=this[p](u[d].params)}for(const d in c)c.hasOwnProperty(d)&&(c[d].type,a[+d]=await this.getDb()[c[d].params].getConnection(),r.push(a[+d]));try{let d=await n.apply(this,a),p;if(Array.isArray(d)&&([d,p]=d),x.type!=="init")return i.format==="xml"||b.type==="xml"?this.successXml(d,Object.assign(b.params,p||{})):this.success(d,Object.assign(b.params,p||{}))}catch(d){await Promise.all([...r.map(w=>w.rollback())]);let p;i.format==="xml"||b.type==="xml"?p=this.errorXml(d):p=this.error(d);for(const w in m){if(!m.hasOwnProperty(w))continue;const K=m[w].params;await this[K].error(d,{response:S.omit(p?.body||{},["stack"])})}return p}finally{await Promise.all([...r.map(d=>d.release())])}}}}function Me(){return function(o,t,e){l(L,o,t,0,"init"),e.value,"$inits"in o||Object.defineProperty(o,"$inits",{value:[]}),o.$inits.push(t)}}const Ne={cookieParse:P.cookieParse,cookieString:W.cookieString,jsonBody:E.jsonBody,rawBody:j,streamBody:A,urlencodedBody:H.urlencodedBody,multipartBody:R.multipartBody,readConfig:U.readConfig,readConfigSync:V.readConfigSync,staticBody:y.staticBody,extensions:y.extensions,getExt:y.getExt,jwtDecode:te,readJsonConfigsSync:oe};exports.ApiError=h.ApiError,exports.Server=_.Server,exports.codeToStatus=_.codeToStatus,exports.Jwt=g.Jwt,exports.Memcached=v.Memcached,exports.AsyncJwt=ee,exports.Controller=de,exports.Model=le,exports.Ssr=ie,exports.Web=he,exports.action=Ce,exports.body=je,exports.config=ge,exports.connection=He,exports.context=be,exports.controller=ve,exports.cookies=ye,exports.db=Se,exports.headers=Ae,exports.helpers=Ne,exports.home=ke,exports.hostname=xe,exports.http=Be,exports.init=Me,exports.json=Re,exports.logerror=We,exports.method=_e,exports.mixin=fe,exports.mount=ue,exports.pool=Ee,exports.protocol=$e,exports.request=pe,exports.selectControllersSchema=ce,exports.stream=qe,exports.subaction=Oe,exports.url=we,exports.xml=Pe;
+        `);
+  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 schemaControllerParams = (schema, method, name, subaction) => {
+  let controllerRow = schema.controllers.find((row) => row.name === name);
+  if (!controllerRow) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Controller ${name} not found is site schema`
+    });
+  }
+  controllerRow = Object.assign({
+    isActive: true,
+    isSitemap: false
+  }, controllerRow);
+  if (!controllerRow.isActive) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Controller ${name} not active is site schema`
+    });
+  }
+  let subactionRow = controllerRow.subactions.find((row) => row.name === subaction);
+  if (!subactionRow) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Subaction ${subaction} not found is site schema`
+    });
+  }
+  subactionRow = Object.assign({
+    isPermission: false,
+    isCheckMethod: false,
+    isLog: false,
+    isActive: true
+  }, subactionRow);
+  if (!subactionRow.isActive) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Subaction ${subaction} not active is site schema`
+    });
+  }
+  let actionRow = schema.actions.find((row) => row.name === subactionRow.action);
+  if (!actionRow) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Action not found is site schema`
+    });
+  }
+  actionRow = Object.assign({
+    isActive: true,
+    method: "any"
+  }, actionRow);
+  if (!actionRow.isActive) {
+    throw new ApiError.ApiError({
+      statusCode: 404,
+      code: 11,
+      message: `Action ${actionRow.name} not active is site schema`
+    });
+  }
+  const allowMethods = (actionRow?.method || "").split(",").map((method2) => method2.trim());
+  if (subactionRow.isCheckMethod) {
+    if (actionRow.method !== "any" && !allowMethods.includes(method)) {
+      throw new ApiError.ApiError({
+        statusCode: 404,
+        code: 11,
+        message: `Controller ${name} action ${actionRow.name} allow only ${actionRow.method} method`
+      });
+    }
+  }
+  return {
+    controller: {
+      id: controllerRow.id,
+      name: controllerRow.name,
+      isActive: controllerRow.isActive,
+      isSitemap: controllerRow.isSitemap
+    },
+    subaction: {
+      id: subactionRow.id,
+      name: subactionRow.name,
+      isPermission: subactionRow.isPermission,
+      isCheckMethod: subactionRow.isCheckMethod,
+      isLog: subactionRow.isLog,
+      isActive: subactionRow.isActive,
+      isSync: !!subactionRow.isSync
+    },
+    action: {
+      id: actionRow.id,
+      name: actionRow.name,
+      isActive: actionRow.isActive,
+      method: actionRow.method
+    }
+  };
+};
+
+class Web {
+  constructor(res, req, context) {
+    this.defaultRequest = {
+      lang: "ru"
+    };
+    this.defaultResponse = {
+      statusCode: 200,
+      headers: { "content-type": "application/json" },
+      body: {}
+    };
+    this.defaultControllerSubaction = {
+      controller: "Index",
+      subaction: "index"
+    };
+    this.res = res;
+    this.req = req;
+    this.res.onAborted(() => new ApiError.ApiError({ message: "The connection was close", code: 1, statusCode: 404 }));
+    this.context = context;
+  }
+  setDefaultRequest(params) {
+    Object.assign(this.defaultRequest, params);
+    return this;
+  }
+  async request(input = {}) {
+    let response = {};
+    try {
+      const query = this.req.getQuery();
+      const request = Object.assign(
+        {},
+        this.defaultRequest,
+        input,
+        querystring.parse(this.req.getQuery())
+      );
+      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() + (query ? `?${query}` : ""),
+        headers: {},
+        stack: this.context.stack || {},
+        getRequest: () => request
+      };
+      this.memcachedKey = `${this.contextWeb.protocol}://${this.contextWeb.hostname}${this.contextWeb.url}`;
+      this.req.forEach((key, value) => this.contextWeb.headers[key] = value);
+      const type = this.contextWeb.headers["content-type"] || "application/json";
+      if (request.controller && request.subaction && this.context.schema) {
+        this.route = this.findRoute(request.controller);
+        Object.defineProperty(this.contextWeb, "$route", {
+          enumerable: false,
+          configurable: false,
+          writable: false,
+          value: this.route
+        });
+        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, false)
+            });
+          }
+          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;
+        }
+      }
+      if (["get", "head"].includes(this.contextWeb.method) && this.contextWeb?.stack?.memcached instanceof Memcached.Memcached) {
+        const memcached = this.contextWeb.stack.memcached;
+        if (memcached.isConnectedServers()) {
+          const cache = await memcached.getPage(this.memcachedKey);
+          if (cache) {
+            const { data, headers } = cache;
+            this.success({
+              body: data.toString(),
+              headers,
+              statusCode: 200
+            });
+          }
+        }
+      }
+      request.controller = request.controller || this.defaultControllerSubaction.controller;
+      request.subaction = request.subaction || this.defaultControllerSubaction.subaction;
+      if (!["get", "head"].includes(this.contextWeb.method)) {
+        if (type.indexOf("application/json") !== -1 || type.indexOf("text/json") !== -1) {
+          Object.assign(request, await jsonBody.jsonBody(this.res));
+        } else if (type.indexOf("multipart/form-data") !== -1) {
+          Object.assign(request, await multipartBody.multipartBody(this.res, this.req));
+          Object.defineProperty(this.contextWeb, "$files", {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: request.files
+          });
+        } else if (type.indexOf("application/x-www-form-urlencoded") !== -1) {
+          Object.assign(request, await urlencodedBody.urlencodedBody(this.res));
+        } else if (type.indexOf("application/xml") !== -1 || type.indexOf("text/xml") !== -1) {
+          const raw = (await rawBody(this.res)).toString();
+          const records = xmljs.xml2js(raw, { compact: true, cdataKey: "_value", textKey: "_value" });
+          Object.assign(request, records || {});
+        } else if (type.indexOf("stream") !== -1) {
+          Object.defineProperty(this.contextWeb, "$stream", {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: streamBody(this.res, this.req, false)
+          });
+        } else if (type.indexOf("binary") !== -1) {
+          await new Promise((resolve) => {
+            const stream = streamBody(this.res, this.req);
+            const temp = os__namespace.tmpdir();
+            const name = "./body_" + crypto.randomBytes(32).toString("hex");
+            const pathToFile = path.resolve(temp, name);
+            const writer = fs__namespace.createWriteStream(pathToFile);
+            stream.pipe(writer);
+            Object.defineProperty(this.contextWeb, "$files", {
+              enumerable: false,
+              configurable: false,
+              writable: false,
+              value: { body: { path: pathToFile } }
+            });
+            stream.on("end", () => resolve(true));
+          });
+        } else {
+          Object.defineProperty(this.contextWeb, "$body", {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: await rawBody(this.res)
+          });
+        }
+      }
+      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.controller);
+      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.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);
+    }
+  }
+  /**
+   * Import controller class
+   */
+  async importController(controllerName) {
+    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.ApiError(
+        {
+          statusCode: 404,
+          code: 12,
+          message: `Class not found for  ${controllerName} route`
+        }
+      );
+    }
+    return controllerClass;
+  }
+  /**
+   * Sync controller
+   */
+  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;
+  }
+  /**
+   * Find route in api routers
+   */
+  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 ${controllerName} not found`
+        }
+      );
+    }
+    return route;
+  }
+  injectContext(obj) {
+    if ("$inject" in obj) {
+      obj.$inject(this.contextWeb);
+    }
+  }
+  async initComponent(obj) {
+    const inits = [.../* @__PURE__ */ new Set(["init", ...obj.$inits || []])];
+    for (const method of inits) {
+      if (obj[method]) {
+        const out = await obj[method]();
+        if (out) {
+          return out;
+        }
+      }
+    }
+  }
+  success(response) {
+    const isStream = response.body instanceof stream$1.Stream;
+    const isBuffer = response.body instanceof Uint8Array;
+    const code = response.statusCode || 200;
+    const status = Server.codeToStatus(code);
+    const body = !isBuffer && !isStream && easyAsh.isObject(response.body) ? JSON.stringify(response.body) : response.body;
+    if (!isStream && ["get", "head"].includes(this.contextWeb.method) && code === 200 && response.memcache && this.contextWeb?.stack?.memcached instanceof Memcached.Memcached) {
+      const memcached = this.contextWeb.stack.memcached;
+      memcached.setPage(this.memcachedKey, response.headers, body, response.memcache).then();
+    }
+    if (!isStream) {
+      this.res.cork(() => {
+        this.res.writeStatus(status);
+        this.writeHeaders(response.headers);
+        this.res.end(body);
+      });
+    } else {
+      this.res.cork(() => {
+        this.res.writeStatus(status);
+        this.writeHeaders(response.headers);
+        body.on("data", (chunk) => {
+          this.res.write(chunk);
+        }).on("end", () => {
+          this.res.end();
+        });
+      });
+    }
+  }
+  /**
+   * Error response
+   */
+  error(e) {
+    const isStream = e instanceof ApiError.ApiError && e.getData() instanceof stream$1.Stream;
+    let status = Server.codeToStatus(404), headers = this.defaultResponse.headers, body = e.message;
+    if (e instanceof ApiError.ApiError) {
+      const data = { isError: true, code: e.getCode(), error: e.getMessage() };
+      status = Server.codeToStatus(e.getStatusCode());
+      headers = e.getHeaders() || this.defaultResponse.headers;
+      if (isStream) {
+        body = e.getData();
+      } else {
+        body = easyAsh.isObject(e.getData()) && Object.keys(e.getData()).length > 0 ? JSON.stringify(e.getData()) : JSON.stringify(data);
+      }
+    }
+    if (!isStream) {
+      this.res.cork(() => {
+        this.res.writeStatus(status);
+        this.writeHeaders(headers);
+        this.res.end(body);
+      });
+    } else {
+      this.res.cork(() => {
+        this.res.writeStatus(status);
+        this.writeHeaders(headers);
+        body.on("data", (chunk) => {
+          this.res.write(chunk);
+        }).on("end", () => {
+          this.res.end();
+        });
+      });
+    }
+  }
+  writeHeaders(headers) {
+    Object.entries(headers).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => this.res.writeHeader(key, v));
+      } else {
+        this.res.writeHeader(key, value);
+      }
+    });
+  }
+}
+
+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: $context.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.ApiError(
+      {
+        statusCode: 404,
+        code: 13,
+        message: `init method response value`
+      }
+    );
+  }
+  return obj;
+};
+
+const xmlOptions = { compact: true, ignoreComment: true, spaces: 4 };
+class Controller {
+  constructor() {
+    // Addition headers that can be add in any place
+    this.responseHeaders = {};
+  }
+  /**
+   * Set cookies
+   * @param name
+   * @param value
+   * @param options
+   */
+  setCookieHeader(name, value, options = {}) {
+    return cookieString.cookieString(name, value, options);
+  }
+  /**
+   * Success request
+   * @param data response params
+   * @param options
+   * @returns
+   */
+  success(data = {}, options) {
+    return {
+      headers: Object.assign({ "content-type": "application/json" }, this.responseHeaders, options?.headers || {}),
+      body: {
+        isError: false,
+        data
+      },
+      memcache: options?.memcache || null,
+      statusCode: options?.statusCode || 200
+    };
+  }
+  /**
+   * Error response
+   * @param err
+   */
+  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 ? {
+      // @ts-ignore
+      status: e.response.status,
+      // @ts-ignore
+      headers: e.response.headers,
+      config: {
+        // @ts-ignore
+        url: e.response.url,
+        // @ts-ignore
+        method: e.response.method,
+        // @ts-ignore
+        params: e.response.params,
+        // @ts-ignore
+        headers: e.response.headers
+      },
+      // @ts-ignore
+      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
+    };
+  }
+  /**
+   * Xml response
+   * @param data response params
+   * @param options addition options
+   */
+  successXml(data = {}, options) {
+    const defaultXml = {
+      _declaration: {
+        _attributes: {
+          version: "1.0",
+          encoding: "utf-8"
+        }
+      }
+    };
+    const response = this.success(data, options);
+    return {
+      headers: Object.assign({ "content-type": "application/xml" }, this.responseHeaders, options?.headers || {}),
+      body: xmljs.js2xml(Object.assign(defaultXml, { body: { ...response.body } }), xmlOptions),
+      memcache: response.memcache
+    };
+  }
+  /**
+   * Error xml response
+   * @param err error object
+   */
+  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/xml" }, e.headers);
+    return {
+      headers,
+      body: xmljs.js2xml(Object.assign(defaultXml, { body: { ...response.body } }), xmlOptions),
+      statusCode: response.statusCode
+    };
+  }
+  // Create 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,
+        stack: this.$context.stack,
+        headers: this.$context.headers,
+        cookies: this.$context.cookies,
+        controller: this.$context.controller,
+        action: this.$context.action,
+        subaction: this.$context.subaction,
+        setResponseHeader: (key, value) => this.setResponseHeader(key, value),
+        setCookieHeader: this.setCookieHeader
+      });
+    }
+    const inits = ["init", ...obj.$inits || []];
+    for (const method of inits) {
+      if (obj[method]) {
+        await obj[method]();
+      }
+    }
+    return obj;
+  }
+  // Create group of libs
+  async $createAll(models) {
+    return Promise.all(models.map((params) => this.$create(...params)));
+  }
+  /**
+   * Inject app context
+   * @param context
+   */
+  $inject(context) {
+    this.$context = context;
+  }
+  getContext() {
+    return this.$context;
+  }
+  getRequest() {
+    return this.$context.getRequest();
+  }
+  getBody() {
+    return this.$context["$body"] || Buffer.from("");
+  }
+  getFiles() {
+    return this.$context["$files"] || {};
+  }
+  getStream() {
+    return this.$context["$stream"] || new stream$1.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;
+  }
+  getPool(key = "home") {
+    return this.getDb()[key];
+  }
+  getStack() {
+    return this.$context.stack;
+  }
+  setResponseHeader(key, value) {
+    if (this.responseHeaders.hasOwnProperty(key)) {
+      this.responseHeaders[key] = Array.isArray(this.responseHeaders[key]) ? this.responseHeaders[key] : [this.responseHeaders[key]];
+      this.responseHeaders[key].push(value);
+    } else {
+      this.responseHeaders[key] = value;
+    }
+  }
+}
+
+class Model {
+  /**
+   * Create model
+   * @param model
+   * @param args
+   */
+  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,
+        stack: this.$context.stack,
+        headers: this.$context.headers,
+        cookies: this.$context.cookies,
+        controller: this.$context.controller,
+        action: this.$context.action,
+        subaction: this.$context.subaction,
+        setResponseHeader: this.$context.setResponseHeader,
+        setCookieHeader: this.$context.setCookieHeader
+      });
+    }
+    if ("init" in obj) {
+      await obj.init();
+    }
+    return obj;
+  }
+  // Create group of libs
+  async $createAll(models) {
+    return Promise.all(models.map((params) => this.$create(...params)));
+  }
+  /**
+   * Inject app context
+   * @param context
+   */
+  $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;
+  }
+  getCookies() {
+    return this.$context.cookies;
+  }
+  getController() {
+    return this.$context.controller;
+  }
+  getAction() {
+    return this.$context.action;
+  }
+  getSubaction() {
+    return this.$context.subaction;
+  }
+  getDb() {
+    return this.$context.db;
+  }
+  getHome() {
+    return this.$context.db.home;
+  }
+  getPool(key = "home") {
+    return this.getDb()[key];
+  }
+  getStack() {
+    return this.$context.stack;
+  }
+  setResponseHeader(key, value) {
+    return this.$context.setResponseHeader(key, value);
+  }
+  setCookieHeader(name, value, options = {}) {
+    return this.$context.setCookieHeader(name, value, options);
+  }
+}
+
+const argumentsSubactionsKey = Symbol("arguments");
+const argumentsConnectionsKey = Symbol("connections");
+const responseSubactionsKey = Symbol("response");
+const responseInitKey = Symbol("init");
+const responseLoggerKey = Symbol("logger");
+const upperCaseFirstLetter = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+function mixin(behaviour, sharedBehaviour = {}) {
+  const instanceKeys = Reflect.ownKeys(behaviour);
+  const sharedKeys = Reflect.ownKeys(sharedBehaviour);
+  const typeTag = Symbol("isa");
+  function _mixin(clazz) {
+    for (const property of instanceKeys) {
+      Object.defineProperty(clazz.prototype, property, { value: behaviour[property] });
+    }
+    Object.defineProperty(clazz.prototype, typeTag, { value: true });
+    return clazz;
+  }
+  for (const property of sharedKeys) {
+    Object.defineProperty(_mixin, property, {
+      //@ts-ignore
+      value: sharedBehaviour[property],
+      enumerable: sharedBehaviour.propertyIsEnumerable(property)
+    });
+  }
+  Object.defineProperty(_mixin, Symbol.hasInstance, {
+    value: (i) => !!i[typeTag]
+  });
+  return _mixin;
+}
+const defineMetadataArgument = (key, target, propertyKey, parameterIndex, argumentType, params) => {
+  const existingArguments = Reflect.getOwnMetadata(
+    key,
+    target,
+    propertyKey
+  ) || {};
+  existingArguments[parameterIndex] = {
+    type: argumentType,
+    params
+  };
+  Reflect.defineMetadata(key, existingArguments, target, propertyKey);
+};
+function request() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "request");
+  };
+}
+function context() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "context");
+  };
+}
+function config() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "config");
+  };
+}
+function method() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "method");
+  };
+}
+function cookies() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "cookies");
+  };
+}
+function hostname() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "hostname");
+  };
+}
+function url() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "url");
+  };
+}
+function protocol() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "protocol");
+  };
+}
+function db() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "db");
+  };
+}
+function headers() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "headers");
+  };
+}
+function controller() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "controller");
+  };
+}
+function action() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "action");
+  };
+}
+function subaction() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "subaction");
+  };
+}
+function body() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "body");
+  };
+}
+function stream() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "stream");
+  };
+}
+function home() {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "home");
+  };
+}
+function pool(name = "home") {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsSubactionsKey, target, propertyKey, parameterIndex, "pool", name);
+  };
+}
+function connection(name = "home") {
+  return function(target, propertyKey, parameterIndex) {
+    defineMetadataArgument(argumentsConnectionsKey, target, propertyKey, parameterIndex, "connection", name);
+  };
+}
+function json(opt = {}) {
+  return function(target, propertyKey, descriptor) {
+    defineMetadataArgument(responseSubactionsKey, target, propertyKey, 0, "json", opt);
+  };
+}
+function xml(opt = {}) {
+  return function(target, propertyKey, descriptor) {
+    defineMetadataArgument(responseSubactionsKey, target, propertyKey, 0, "xml", opt);
+  };
+}
+function logerror(name) {
+  return function(target, propertyKey, descriptor) {
+    defineMetadataArgument(responseLoggerKey, target, propertyKey, name, "logger", name);
+  };
+}
+function http(beforeCreate) {
+  return function(target, propertyKey, descriptor) {
+    const opts = {
+      format: "json"
+    };
+    const method2 = descriptor.value;
+    descriptor.value = async function() {
+      if (beforeCreate) {
+        Object.assign(opts, await beforeCreate.apply(this) || {});
+      }
+      const args = [];
+      const connections = [];
+      const existingArguments = Reflect.getOwnMetadata(
+        argumentsSubactionsKey,
+        target,
+        propertyKey
+      ) || {};
+      const existingConnections = Reflect.getOwnMetadata(
+        argumentsConnectionsKey,
+        target,
+        propertyKey
+      ) || {};
+      const existingLoggers = Reflect.getOwnMetadata(
+        responseLoggerKey,
+        target,
+        propertyKey
+      ) || {};
+      const response = Reflect.getOwnMetadata(
+        responseSubactionsKey,
+        target,
+        propertyKey
+      )?.[0] || { type: "json", params: {} };
+      const responseInit = Reflect.getOwnMetadata(
+        responseInitKey,
+        target,
+        propertyKey
+      )?.[0] || { type: "", params: {} };
+      for (const key in existingArguments) {
+        if (!existingArguments.hasOwnProperty(key)) {
+          continue;
+        }
+        const getterName = `get${upperCaseFirstLetter(existingArguments[key].type)}`;
+        args[+key] = this[getterName](existingArguments[key].params);
+      }
+      for (const key in existingConnections) {
+        if (!existingConnections.hasOwnProperty(key)) {
+          continue;
+        }
+        existingConnections[key].type;
+        args[+key] = await this.getDb()[existingConnections[key].params].getConnection();
+        connections.push(args[+key]);
+      }
+      try {
+        let out = await method2.apply(this, args), opt;
+        Array.isArray(out) && ([out, opt] = out);
+        if (responseInit.type !== "init") {
+          if (opts.format === "xml" || response.type === "xml") {
+            return this.successXml(out, Object.assign(response.params, opt || {}));
+          }
+          return this.success(out, Object.assign(response.params, opt || {}));
+        }
+      } catch (e) {
+        await Promise.all([...connections.map((connection2) => connection2.rollback())]);
+        let output;
+        if (opts.format === "xml" || response.type === "xml") {
+          output = this.errorXml(e);
+        } else {
+          output = this.error(e);
+        }
+        for (const key in existingLoggers) {
+          if (!existingLoggers.hasOwnProperty(key)) {
+            continue;
+          }
+          const logger = existingLoggers[key].params;
+          await this[logger].error(e, { response: easyAsh.omit(output?.body || {}, ["stack"]) });
+        }
+        return output;
+      } finally {
+        await Promise.all([...connections.map((connection2) => connection2.release())]);
+      }
+    };
+  };
+}
+function init() {
+  return function(target, propertyKey, descriptor) {
+    defineMetadataArgument(responseInitKey, target, propertyKey, 0, "init");
+    descriptor.value;
+    if (!("$inits" in target)) {
+      Object.defineProperty(target, "$inits", { value: [] });
+    }
+    target.$inits.push(propertyKey);
+  };
+}
+
+const helpers = {
+  cookieParse: cookieParse.cookieParse,
+  cookieString: cookieString.cookieString,
+  jsonBody: jsonBody.jsonBody,
+  rawBody,
+  streamBody,
+  urlencodedBody: urlencodedBody.urlencodedBody,
+  multipartBody: multipartBody.multipartBody,
+  readConfig: readConfig.readConfig,
+  readConfigSync: readConfigSync.readConfigSync,
+  staticBody: staticBody.staticBody,
+  extensions: staticBody.extensions,
+  getExt: staticBody.getExt,
+  jwtDecode,
+  readJsonConfigsSync
+};
+
+exports.ApiError = ApiError.ApiError;
+exports.Server = Server.Server;
+exports.codeToStatus = Server.codeToStatus;
+exports.Jwt = Jwt.Jwt;
+exports.Memcached = Memcached.Memcached;
+exports.AsyncJwt = AsyncJwt;
+exports.Controller = Controller;
+exports.Model = Model;
+exports.Ssr = Ssr;
+exports.Web = Web;
+exports.action = action;
+exports.body = body;
+exports.config = config;
+exports.connection = connection;
+exports.context = context;
+exports.controller = controller;
+exports.cookies = cookies;
+exports.db = db;
+exports.headers = headers;
+exports.helpers = helpers;
+exports.home = home;
+exports.hostname = hostname;
+exports.http = http;
+exports.init = init;
+exports.json = json;
+exports.logerror = logerror;
+exports.method = method;
+exports.mixin = mixin;
+exports.mount = mountWithContext;
+exports.pool = pool;
+exports.protocol = protocol;
+exports.request = request;
+exports.selectControllersSchema = selectControllersSchema;
+exports.stream = stream;
+exports.subaction = subaction;
+exports.url = url;
+exports.xml = xml;