@jwn-js/common 1.3.1 → 1.3.5

package/index.d.ts

@@ -1,5 +1,5 @@
 import * as formidable from 'formidable';
-import * as stream from 'stream';
+import * as stream$1 from 'stream';
 import { Stream } from 'stream';
 import * as uWebSockets_js from 'uWebSockets.js';
 import { HttpResponse, HttpRequest } from 'uWebSockets.js';
@@ -8,6 +8,7 @@ export { Server, Handler as ServerHandler, Options as ServerOptions, Routes as S
 export { Jwt } from './Jwt';
 import { Client } from 'memjs';
 import { Query } from 'buildmsql';
+export { Context as ContextSsr } from 'vite-ssr-vue';
 
 declare class Memcached {
     memjs: Client;
@@ -57,19 +58,21 @@ declare class Memcached {
  */
 declare function staticBody(res: HttpResponse, req: HttpRequest, base: string): Promise<void>;
 
-interface Context$3 {
+interface OptionsSsr {
     readonly manifest: Record<string, any>;
     readonly memcached: Memcached;
     readonly [key: string]: any;
 }
+declare type EntryFunction = (url: string, opt: Record<string, any>) => Promise<any>;
+
 /**
  * Ssr handler for production
  */
 declare class Ssr {
     res: HttpResponse;
     req: HttpRequest;
-    context: Context$3;
-    entry: CallableFunction;
+    context: OptionsSsr;
+    entry: EntryFunction | any;
     /**
      * @constructor
      * @param res response
@@ -77,7 +80,7 @@ declare class Ssr {
      * @param context params
      * @param entry - entry point function
      */
-    constructor(res: HttpResponse, req: HttpRequest, context: Context$3, entry: CallableFunction);
+    constructor(res: HttpResponse, req: HttpRequest, context: OptionsSsr, entry: EntryFunction | any);
     /**
      * @param request addition request params
      */
@@ -133,7 +136,7 @@ declare class ApiError extends Error {
     getHeaders(): Record<string, string>;
 }
 
-declare type method$1 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+declare type method$2 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
 declare module "uWebSockets.js" {
     interface HttpRequest {
         cookies: Record<string, any>;
@@ -141,16 +144,16 @@ declare module "uWebSockets.js" {
 }
 interface Route$1 {
     name: string;
-    method?: method$1 | Array<method$1>;
+    method?: method$2 | Array<method$2>;
     component: any;
 }
-interface Context$2 {
+interface OptionsWeb {
     readonly routes: Array<Route$1>;
     readonly config: Config$1;
     readonly db: Record<string, Query>;
     readonly [key: string]: any;
 }
-interface Response {
+interface Response$1 {
     statusCode: number;
     headers: Record<string, any>;
     body: any;
@@ -181,7 +184,7 @@ interface ContextWeb {
         id: number;
         name: string;
         isActive: boolean;
-        method: method$1;
+        method: method$2;
     };
     [key: string]: any;
 }
@@ -205,7 +208,7 @@ interface ContextWebController extends ContextWeb {
 declare class Web {
     res: HttpResponse;
     req: HttpRequest;
-    context: Context$2;
+    context: OptionsWeb;
     defaultRequest: {
         controller: string;
         subaction: string;
@@ -226,7 +229,7 @@ declare class Web {
      * @param req request
      * @param context params
      */
-    constructor(res: HttpResponse, req: HttpRequest, context: Context$2);
+    constructor(res: HttpResponse, req: HttpRequest, context: OptionsWeb);
     request(request?: Record<string, any>): Promise<void>;
     /**
      * Import controller class
@@ -255,14 +258,14 @@ declare class Web {
     /**
      * Success response
      */
-    success(response: Response): void;
+    success(response: Response$1): void;
     /**
      * Error response
      */
     error(e: ApiError | Error): void;
 }
 
-declare type method = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+declare type method$1 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
 declare module "uWebSockets.js" {
     interface HttpRequest {
         cookies: Record<string, any>;
@@ -270,7 +273,7 @@ declare module "uWebSockets.js" {
 }
 interface Route {
     name: string;
-    method?: method | Array<method>;
+    method?: method$1 | Array<method$1>;
     component: any;
 }
 interface Config {
@@ -300,9 +303,9 @@ interface TestContext {
         id: number;
         name: string;
         isActive: boolean;
-        method: method;
+        method: method$1;
     };
-    method?: method;
+    method?: method$1;
     cookies?: Record<string, any>;
     hostname?: string;
     protocol?: string;
@@ -358,7 +361,7 @@ declare class Model$1 {
         id: number;
         name: string;
         isActive: boolean;
-        method: method$1;
+        method: method$2;
     };
     getSubaction(): {
         id: number;
@@ -491,7 +494,7 @@ declare class Controller {
         id: number;
         name: string;
         isActive: boolean;
-        method: method$1;
+        method: method$2;
     };
     getSubaction(): {
         id: number;
@@ -543,7 +546,7 @@ declare class Model {
         id: number;
         name: string;
         isActive: boolean;
-        method: method$1;
+        method: method$2;
     };
     getSubaction(): {
         id: number;
@@ -555,12 +558,123 @@ declare class Model {
     };
 }
 
+/**
+ * Response interface
+ */
+interface Response {
+    memcache?: number | null;
+    headers?: Record<string, any>;
+    statusCode?: number;
+}
+declare type CallbackFunctionAny = (...args: any[]) => any;
+/**
+ * Mixin helper for decorators
+ * @param behaviour
+ * @param sharedBehaviour
+ * http://raganwald.com/2015/06/26/decorators-in-es7.html
+ * http://raganwald.com/2015/06/17/functional-mixins.html
+ * https://habr.com/ru/post/277021/
+ */
+declare function mixin<T extends Record<string, any>>(behaviour: T, sharedBehaviour?: {}): (clazz: any) => any;
+/**
+ * @request() decorator
+ */
+declare function request(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @context() decorator
+ */
+declare function context(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @config() decorator
+ */
+declare function config(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @method() decorator
+ */
+declare function method(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @cookies() decorator
+ */
+declare function cookies(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @hostname() decorator
+ */
+declare function hostname(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @url() decorator
+ */
+declare function url(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @protocol() decorator
+ */
+declare function protocol(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @db() decorator
+ */
+declare function db(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @headers() decorator
+ */
+declare function headers(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @controller() decorator
+ */
+declare function controller(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @action() decorator
+ */
+declare function action(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @subaction() decorator
+ */
+declare function subaction(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @body() decorator
+ */
+declare function body(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @stream() decorator
+ */
+declare function stream(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @home() decorator
+ */
+declare function home(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @connection() decorator
+ */
+declare function connection(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Json response
+ * @param opt response options
+ */
+declare function json(opt?: Response): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Xml response
+ * @param opt response options
+ */
+declare function xml(opt?: Response): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Logger
+ * @param name logger name
+ */
+declare function logerror(name: string): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Subaction method decorator
+ * @http() decorator
+ */
+declare function http(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * @init decorator
+ */
+declare function init(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+
 declare const helpers: {
     cookieParse: (str: string) => Record<string, any>;
     cookieString: (name: string, value: any, options?: Record<string, any>) => string;
     jsonBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<any>;
     rawBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<Buffer>;
-    streamBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => stream.Stream;
+    streamBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => stream$1.Stream;
     urlencodedBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<any>;
     multipartBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest, options?: formidable.Options) => Promise<any>;
     readConfig: (jsonfile: string) => Promise<any>;
@@ -570,4 +684,4 @@ declare const helpers: {
     getExt: (path: string) => string;
 };
 
-export { Controller, Memcached, Model, Ssr, Web, helpers, mountWithContext as mount };
+export { ContextWeb, Controller, Memcached, Model, OptionsSsr, OptionsWeb, Route$1 as Route, Ssr, Web, action, body, config, connection, context, controller, cookies, db, headers, helpers, home, hostname, http, init, json, logerror, method, mixin, mountWithContext as mount, protocol, request, stream, subaction, url, xml };

package/index.js

@@ -6,7 +6,7 @@ var ApiError = require('./ApiError.js');
 var Server = require('./Server-77093d28.js');
 var Jwt = require('./Jwt.js');
 var ApiError$1 = require('./ApiError-b517f53a.js');
-var stream = require('stream');
+var stream$1 = require('stream');
 var querystring = require('querystring');
 var formidable = require('formidable');
 var path = require('path');
@@ -15,6 +15,7 @@ require('dns');
 require('uWebSockets.js');
 var easyAsh = require('easy-ash');
 var xmljs = require('xml-js');
+require('reflect-metadata');
 require('crypto');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -129,17 +130,17 @@ function readRaw(res, cb, 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);
+  const stream = new stream$1.PassThrough();
+  stream.headers = {};
+  req.forEach((key, val) => stream.headers[key] = val);
   res.onData((chunk, isLast) => {
-    stream$1.write(Buffer.from(Buffer.from(chunk)));
-    stream$1.resume();
+    stream.write(Buffer.from(Buffer.from(chunk)));
+    stream.resume();
     if (isLast) {
-      stream$1.end();
+      stream.end();
     }
   });
-  return stream$1;
+  return stream;
 };
 
 const urlencodedBody = (res, req) => new Promise((resolve, reject) => {
@@ -169,18 +170,18 @@ const multipartBody = (res, req, options = { multiples: true }) => new Promise(a
   const err = new ApiError$1.ApiError({ message: "Can`t parse body", code: 1, statusCode: 404 });
   res.onAborted(() => err);
   try {
-    const stream$1 = new stream.PassThrough();
-    stream$1.headers = {};
-    req.forEach((key, val) => stream$1.headers[key] = val);
+    const stream = new stream$1.PassThrough();
+    stream.headers = {};
+    req.forEach((key, val) => stream.headers[key] = val);
     res.onData((chunk, isLast) => {
-      stream$1.write(Buffer.from(Buffer.from(chunk)));
-      stream$1.resume();
+      stream.write(Buffer.from(Buffer.from(chunk)));
+      stream.resume();
       if (isLast) {
-        stream$1.end();
+        stream.end();
       }
     });
     const form = formidable__default['default'](options);
-    form.parse(stream$1, (err2, fields, files) => {
+    form.parse(stream, (err2, fields, files) => {
       if (err2) {
         reject(err2);
       }
@@ -761,7 +762,7 @@ class Web {
   }
 }
 
-const config = readConfigSync("./connect.json");
+const config$1 = readConfigSync("./connect.json");
 const mountWithContext = async ($class, $context, request = {}) => {
   const initComponent = async (obj2) => {
     let out;
@@ -776,12 +777,12 @@ const mountWithContext = async ($class, $context, request = {}) => {
     }
   };
   $context = Object.assign({
-    config,
+    config: config$1,
     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,
+    hostname: config$1.server?.development?.host,
     protocol: "http",
     headers: {}
   }, $context);
@@ -914,7 +915,7 @@ class Controller {
     return this.$context["$body"] || Buffer.from("");
   }
   getStream() {
-    return this.$context["$stream"] || new stream.PassThrough().end();
+    return this.$context["$stream"] || new stream$1.PassThrough().end();
   }
   getConfig() {
     return this.$context.config;
@@ -1003,6 +1004,206 @@ class Model {
   }
 }
 
+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, {
+      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 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() {
+  return function(target, propertyKey, descriptor) {
+    const method2 = descriptor.value;
+    const args = [];
+    const connections = [];
+    descriptor.value = async function() {
+      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]();
+      }
+      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 {
+        const out = await method2.apply(this, args);
+        if (responseInit.type !== "init") {
+          if (response.type === "xml") {
+            return this.successXml(out, response.params);
+          }
+          return this.success(out, response.params);
+        }
+      } catch (e) {
+        await Promise.all([...connections.map((connection2) => connection2.rollback())]);
+        for (const key in existingLoggers) {
+          if (!existingLoggers.hasOwnProperty(key)) {
+            continue;
+          }
+          const logger = existingLoggers[key].params;
+          await this[logger].error(e);
+        }
+        if (response.type === "xml") {
+          return this.errorXml(e);
+        }
+        return this.error(e);
+      } 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: Server.cookieParse,
   cookieString,
@@ -1027,5 +1228,28 @@ exports.Memcached = Memcached;
 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.protocol = protocol;
+exports.request = request;
+exports.stream = stream;
+exports.subaction = subaction;
+exports.url = url;
+exports.xml = xml;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jwn-js/common",
   "private": false,
-  "version": "1.3.1",
+  "version": "1.3.5",
   "description": "@jwn-js/common package",
   "main": "./index.js",
   "types": "./index.d.ts",