express-ext 0.1.12 → 0.1.16

package/src/LoadSearchController.ts

@@ -1,8 +1,8 @@
 import {Request, Response} from 'express';
-import {handleError} from './http';
+import {handleError, Log} from './http';
 import {LoadController, ViewService} from './LoadController';
 import {Attribute, Attributes} from './metadata';
-import {Filter, format, fromRequest, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult} from './search';
+import {buildArray, Filter, format, fromRequest, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult} from './search';
 import {getMetadataFunc} from './search_func';
 
 export class LoadSearchController<T, ID, S extends Filter> extends LoadController<T, ID> {
@@ -12,7 +12,8 @@ export class LoadSearchController<T, ID, S extends Filter> extends LoadControlle
   numbers?: string[];
   fields?: string;
   excluding?: string;
-  constructor(log: (msg: string) => void, public find: (s: S, limit?: number, skip?: number|string, fields?: string[]) => Promise<SearchResult<T>>, viewService: ViewService<T, ID> | ((id: ID, ctx?: any) => Promise<T>), keys?: Attributes|Attribute[]|string[], config?: SearchConfig|boolean, dates?: string[], numbers?: string[]) {
+  array?: string[];
+  constructor(log: Log, public find: (s: S, limit?: number, skip?: number|string, fields?: string[]) => Promise<SearchResult<T>>, viewService: ViewService<T, ID> | ((id: ID, ctx?: any) => Promise<T>), keys?: Attributes|Attribute[]|string[], config?: SearchConfig|boolean, dates?: string[], numbers?: string[]) {
     super(log, viewService, keys);
     this.search = this.search.bind(this);
     if (config) {
@@ -37,7 +38,7 @@ export class LoadSearchController<T, ID, S extends Filter> extends LoadControlle
     }
   }
   search(req: Request, res: Response) {
-    const s = fromRequest<S>(req, this.fields, this.excluding);
+    const s = fromRequest<S>(req, buildArray(this.array, this.fields, this.excluding));
     const l = getParameters(s, this.config);
     const s2 = format(s, this.dates, this.numbers);
     this.find(s2, l.limit, l.skipOrRefId, l.fields)

package/src/LogController.ts

@@ -1,4 +1,5 @@
-import {Request, Response} from 'express';
+import { Request, Response } from 'express';
+import { SimpleMap } from './log';
 
 export interface NumberMap {
   [key: string]: number;
@@ -6,6 +7,8 @@ export interface NumberMap {
 export interface LogConfig {
   level?: string;
   map?: LogMapConfig;
+  constants?: SimpleMap;
+  name?: Name;
 }
 export interface LogMapConfig {
   time?: string;
@@ -17,15 +20,51 @@ export interface LogMap {
   level: string;
   msg: string;
 }
+export interface Name {
+  trace: string;
+  debug: string;
+  info: string;
+  warn: string;
+  error: string;
+  panic: string;
+  fatal: string;
+}
 export interface Logger {
+  name: Name;
   level: number;
   map: LogMap;
+  constants?: SimpleMap;
+  trace(msg: string, m?: SimpleMap, ctx?: any): void;
+  debug(msg: string, m?: SimpleMap, ctx?: any): void;
+  info(msg: string, m?: SimpleMap, ctx?: any): void;
+  warn(msg: string, m?: SimpleMap, ctx?: any): void;
+  error(msg: string, m?: SimpleMap, ctx?: any): void;
+  panic(msg: string, m?: SimpleMap, ctx?: any): void;
+  fatal(msg: string, m?: SimpleMap, ctx?: any): void;
+  isLevelEnabled(level: number): boolean;
+  isTraceEnabled(): boolean;
+  isDebugEnabled(): boolean;
+  isInfoEnabled(): boolean;
+  isWarnEnabled(): boolean;
+  isErrorEnabled(): boolean;
+  isPanicEnabled(): boolean;
+  isFatalEnabled(): boolean;
 }
-
+export const map: NumberMap = {
+  TRACE: -2,
+  DEBUG: -1,
+  INFO: 0,
+  WARN: 1,
+  ERROR: 2,
+  PANIC: 3,
+  FATAL: 4
+};
 export class LogController {
-  map?: NumberMap;
-  constructor(public logger: Logger, mp?: NumberMap) {
-    this.map = mp;
+  map: NumberMap;
+  update: (logger: Logger, obj: LogConfig, mp: NumberMap) => boolean;
+  constructor(public logger: Logger, updateL?: (logger: Logger, obj: LogConfig, mp: NumberMap) => boolean, mp?: NumberMap) {
+    this.map = (mp ? mp : map);
+    this.update = updateL ? updateL : updateLog;
     this.config = this.config.bind(this);
   }
   config(req: Request, res: Response) {
@@ -33,38 +72,65 @@ export class LogController {
     if (!obj || obj === '') {
       return res.status(400).end('The request body cannot be empty');
     }
-    if (!this.logger || !this.map) {
+    if (!this.logger) {
       return res.status(503).end('Logger is not available');
     }
-    if (!this.map) {
-      return res.status(503).end('Map is not available');
-    }
-    let changed = false;
-    if (obj.level && typeof obj.level === 'string' && obj.level.length > 0) {
-      const lv = this.map[obj.level.toUpperCase()];
-      if (lv !== undefined) {
-        this.logger.level = lv;
-        changed = true;
-      }
-    }
-    if (obj.map) {
-      if (obj.map.level && typeof obj.map.level === 'string' && obj.map.level.length > 0) {
-        this.logger.map.level = obj.map.level;
-        changed = true;
-      }
-      if (obj.map.time && typeof obj.map.time === 'string' && obj.map.time.length > 0) {
-        this.logger.map.time = obj.map.time;
-        changed = true;
-      }
-      if (obj.map.msg && typeof obj.map.msg === 'string' && obj.map.msg.length > 0) {
-        this.logger.map.msg = obj.map.msg;
-        changed = true;
+    if (typeof obj.level === 'string' && obj.level.length > 0) {
+      if (!this.map) {
+        return res.status(503).end('Map is not available');
       }
     }
+    const changed = this.update(this.logger, obj, this.map);
     if (changed) {
-      return res.status(200).end('true');
+      return res.status(200).json(true).end();
     } else {
-      return res.status(204).end('false');
+      return res.status(204).json(false).end();
+    }
+  }
+}
+export function updateLog(logger: Logger, obj: LogConfig, mp: NumberMap): boolean {
+  let changed = false;
+  if (typeof obj.level === 'string' && obj.level.length > 0) {
+    const lv = mp[obj.level.toUpperCase()];
+    if (lv !== undefined) {
+      logger.level = lv;
+      changed = true;
+    }
+  }
+  if (obj.map) {
+    if (typeof obj.map.level === 'string' && obj.map.level.length > 0) {
+      logger.map.level = obj.map.level;
+      changed = true;
+    }
+    if (typeof obj.map.time === 'string' && obj.map.time.length > 0) {
+      logger.map.time = obj.map.time;
+      changed = true;
+    }
+    if (typeof obj.map.msg === 'string' && obj.map.msg.length > 0) {
+      logger.map.msg = obj.map.msg;
+      changed = true;
+    }
+  }
+  if (obj.constants !== undefined && typeof obj.constants === 'object') {
+    const ks = Object.keys(obj.constants);
+    if (ks.length > 0) {
+      logger.constants = obj.constants;
+    } else {
+      logger.constants = undefined;
+    }
+    changed = true;
+  }
+  if (obj.name) {
+    if (typeof obj.name.trace === 'string'
+      && typeof obj.name.debug === 'string'
+      && typeof obj.name.info === 'string'
+      && typeof obj.name.warn === 'string'
+      && typeof obj.name.error === 'string'
+      && typeof obj.name.panic === 'string'
+      && typeof obj.name.fatal === 'string') {
+      logger.name = obj.name;
+      changed = true;
     }
   }
+  return changed;
 }

package/src/LowCodeController.ts

@@ -1,9 +1,9 @@
 import {Request, Response} from 'express';
 import {ResultInfo, StatusConfig} from './edit';
 import {GenericController, GenericService} from './GenericController';
-import {handleError} from './http';
+import {handleError, Log} from './http';
 import {ErrorMessage} from './metadata';
-import {Filter, format, fromRequest, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult} from './search';
+import {buildArray, Filter, format, fromRequest, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult} from './search';
 import {getMetadataFunc} from './search_func';
 
 export interface LowCodeConfig extends StatusConfig, SearchConfig {
@@ -18,7 +18,8 @@ export class LowCodeController<T, ID, S extends Filter> extends GenericControlle
   numbers?: string[];
   fields?: string;
   excluding?: string;
-  constructor(log: (msg: string) => void, public lowCodeService: Service<T, ID, number|ResultInfo<T>, S>, config?: LowCodeConfig, validate?: (obj: T, patch?: boolean) => Promise<ErrorMessage[]>, dates?: string[], numbers?: string[]) {
+  array?: string[];
+  constructor(log: Log, public lowCodeService: Service<T, ID, number|ResultInfo<T>, S>, config?: LowCodeConfig, validate?: (obj: T, patch?: boolean) => Promise<ErrorMessage[]>, dates?: string[], numbers?: string[]) {
     super(log, lowCodeService, config, validate);
     this.search = this.search.bind(this);
     this.config = initializeConfig(config);
@@ -37,7 +38,7 @@ export class LowCodeController<T, ID, S extends Filter> extends GenericControlle
     }
   }
   search(req: Request, res: Response) {
-    const s = fromRequest<S>(req, this.fields, this.excluding);
+    const s = fromRequest<S>(req, buildArray(this.array, this.fields, this.excluding));
     const l = getParameters(s, this.config);
     const s2 = format(s, this.dates, this.numbers);
     this.lowCodeService.search(s2, l.limit, l.skipOrRefId, l.fields)

package/src/SearchController.ts

@@ -1,13 +1,14 @@
 import {Request, Response} from 'express';
-import {handleError} from './http';
-import {Filter, format, fromRequest, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult} from './search';
+import {handleError, Log} from './http';
+import {buildArray, Filter, format, fromRequest, getParameters, initializeConfig, jsonResult, SearchConfig, SearchResult} from './search';
 
 export class SearchController<T, S extends Filter> {
   config?: SearchConfig;
   csv?: boolean;
   fields?: string;
   excluding?: string;
-  constructor(protected log: (msg: string) => void, public find: (s: S, limit?: number, skip?: number|string, fields?: string[]) => Promise<SearchResult<T>>, config?: SearchConfig|boolean, public dates?: string[], public numbers?: string[]) {
+  array?: string[];
+  constructor(protected log: Log, public find: (s: S, limit?: number, skip?: number|string, fields?: string[]) => Promise<SearchResult<T>>, config?: SearchConfig|boolean, public dates?: string[], public numbers?: string[]) {
     this.search = this.search.bind(this);
     if (config) {
       if (typeof config === 'boolean') {
@@ -26,7 +27,7 @@ export class SearchController<T, S extends Filter> {
     }
   }
   search(req: Request, res: Response) {
-    const s = fromRequest<S>(req, this.fields, this.excluding);
+    const s = fromRequest<S>(req, buildArray(this.array, this.fields, this.excluding));
     const l = getParameters(s, this.config);
     const s2 = format(s, this.dates, this.numbers);
     this.find(s2, l.limit, l.skipOrRefId, l.fields)

package/src/health.ts

@@ -16,7 +16,7 @@ export interface HealthChecker {
   check(): Promise<AnyMap>;
 }
 
-export async function check(checkers: HealthChecker[]): Promise<Health> {
+export async function health(checkers: HealthChecker[]): Promise<Health> {
   const p: Health = { status: 'UP' };
   const total = checkers.length - 1;
   let count = 0;

package/src/http.ts

@@ -1,6 +1,8 @@
 import {Request, Response} from 'express';
 import {Attribute} from './metadata';
 
+export type Log = (msg: string) => void;
+export type LogFunc = Log;
 export function handleError(err: any, res: Response, log?: (msg: string) => void) {
   if (log) {
     log(toString(err));

package/src/index.ts

@@ -1,3 +1,4 @@
+import {NextFunction, Request, Response} from 'express';
 import {GenericController} from './GenericController';
 import {GenericSearchController} from './GenericSearchController';
 import {HealthController} from './HealthController';
@@ -26,6 +27,7 @@ export {Service as LowCodeService};
 export * from './health';
 export * from './HealthController';
 export * from './LogController';
+export * from './log';
 export * from './http';
 export * from './metadata';
 export * from './view';
@@ -39,3 +41,20 @@ export * from './edit';
 export * from './GenericController';
 export * from './GenericSearchController';
 export * from './LowCodeController';
+
+export interface AccessConfig {
+  origin: string;
+  credentials: string;
+  methods: string;
+  headers: string;
+}
+export type AccessControlAllowConfig = AccessConfig;
+export function allow(access: AccessConfig): (req: Request, res: Response, next: NextFunction) => void {
+  return (req: Request, res: Response, next: NextFunction) => {
+    res.header('Access-Control-Allow-Origin', access.origin);
+    res.header('Access-Control-Allow-Credentials', access.credentials);
+    res.header('Access-Control-Allow-Methods', access.methods);
+    res.setHeader('Access-Control-Allow-Headers', access.headers);
+    next();
+  };
+}

package/src/log.ts

@@ -0,0 +1,217 @@
+import { NextFunction } from 'express';
+import { ParamsDictionary, Request, Response } from 'express-serve-static-core';
+import { ParsedQs } from 'qs';
+import { PassThrough } from 'stream';
+
+export interface LogConf {
+  log?: boolean;
+  separate?: boolean;
+  skips?: string;
+  request?: string;
+  response?: string;
+  duration?: string;
+  status?: string;
+  size?: string;
+}
+export interface MiddleLog {
+  log?: boolean;
+  separate?: boolean;
+  skips: string[];
+  duration: string;
+  request: string;
+  response: string;
+  status: string;
+  size: string;
+}
+export interface SimpleMap {
+  [key: string]: string|number|boolean|Date;
+}
+export function createConfig(c?: LogConf): MiddleLog {
+  if (!c) {
+    return {skips: [], duration: 'duration', request: '', response: '', status: '', size: ''};
+  }
+  const l: MiddleLog = {
+    log: c.log,
+    separate: c.separate,
+    skips: c.skips ? c.skips.split(',') : [],
+    duration: c.duration ? c.duration : 'duration',
+    request: c.request ? c.request : '',
+    response: c.response ? c.response : '',
+    status: c.status ? c.status : '',
+    size: c.size ? c.size : ''
+  };
+  return l;
+}
+export function skip(skips: string[], url: string): boolean {
+  if (skips.length === 0) {
+    return false;
+  }
+  const u = removeUrlParams(url);
+  for (const s of skips) {
+    if (u.endsWith(s)) {
+      return true;
+    }
+  }
+  return false;
+}
+export function removeUrlParams(url: string): string {
+  const startParams = url.indexOf('?');
+  return startParams !== -1 ? url.substring(0, startParams) : url;
+}
+export interface Middleware {
+  conf: MiddleLog;
+}
+const o = 'OPTIONS';
+export class MiddlewareLogger {
+  constructor(public write: (msg: string, m?: SimpleMap) => void, conf?: LogConf, public build?: (req: Request<ParamsDictionary, any, any, ParsedQs, Record<string, any>>, m: SimpleMap) => SimpleMap) {
+    this.log = this.log.bind(this);
+    this.conf = createConfig(conf);
+  }
+  conf: MiddleLog;
+  log(req: Request<ParamsDictionary, any, any, ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>, number>, next: NextFunction) {
+    const m = req.method;
+    if (m !== o && this.conf.log && !skip(this.conf.skips, req.originalUrl)) {
+      const start = process.hrtime();
+      const x = this.conf.request;
+      let r = false;
+      if (m !== 'GET' && m !== 'DELETE') {
+        r = true;
+      }
+      const msg = `${m} ${req.originalUrl}`;
+      if (this.conf.separate && r) {
+        if (this.conf.request.length > 0) {
+          const op: SimpleMap = {};
+          op[x] = JSON.stringify(req.body);
+          if (this.build) {
+            const op2 = this.build(req, op);
+            this.write(msg, op2);
+          } else {
+            this.write(msg, op);
+          }
+        }
+      }
+      const chunks: Uint8Array[] = [];
+      mapResponseBody(res, chunks);
+      res.on('finish', () => {
+          const duration = getDurationInMilliseconds(start);
+          const op: SimpleMap = {};
+          if (r && !this.conf.separate && this.conf.request.length > 0) {
+            op[x] = JSON.stringify(req.body);
+          }
+          if (this.conf.response.length > 0) {
+            const rsBody = Buffer.concat(chunks).toString();
+            op[this.conf.response] = rsBody;
+          }
+          if (this.conf.status.length > 0) {
+            op[this.conf.status] = res.statusCode;
+          }
+          if (this.conf.size.length > 0) {
+            if ('_contentLength' in res) {
+              op[this.conf.size] = (res as any)['_contentLength'];
+            } else if (res.hasHeader('content-length')) {
+              const l = res.getHeader('content-length');
+              if (typeof l === 'number' || typeof l === 'string') {
+                op[this.conf.size] = l;
+              }
+            }
+          }
+          op[this.conf.duration] = duration;
+          if (this.build) {
+            const op2 = this.build(req, op);
+            this.write(msg, op2);
+          } else {
+            this.write(msg, op);
+          }
+      });
+      next();
+    } else {
+      next();
+    }
+  }
+}
+const mapResponseBody = (res: Response<any, Record<string, any>, number>, chunks: Uint8Array[]) => {
+  const defaultWrite = res.write.bind(res);
+  const defaultEnd = res.end.bind(res);
+  const ps = new PassThrough();
+
+  ps.on('data', (data: any) => chunks.push(data));
+
+  (res as any).write = (...args: any) => {
+      (ps as any).write(...args);
+      (defaultWrite as any)(...args);
+  };
+
+  (res as any).end = (...args: any) => {
+      ps.end(...args);
+      defaultEnd(...args);
+  };
+};
+const NS_PER_SEC = 1e9;
+const NS_TO_MS = 1e6;
+const getDurationInMilliseconds = (start: [number, number] | undefined) => {
+  const diff = process.hrtime(start);
+  return (diff[0] * NS_PER_SEC + diff[1]) / NS_TO_MS;
+};
+
+export class MiddlewareController {
+  constructor(public logger: Middleware) {
+    this.config = this.config.bind(this);
+  }
+  config(req: Request, res: Response) {
+    const obj: MiddleLog = req.body;
+    if (!obj || (obj as any) === '') {
+      return res.status(400).end('The request body cannot be empty');
+    }
+    if (!this.logger) {
+      return res.status(503).end('Logger is not available');
+    }
+    let changed = false;
+    if (obj.log !== undefined) {
+      this.logger.conf.log = obj.log;
+      changed = true;
+    }
+    if (obj.separate !== undefined) {
+      this.logger.conf.separate = obj.separate;
+      changed = true;
+    }
+    if (Array.isArray(obj.skips)) {
+      if (isValidSkips(obj.skips)) {
+        this.logger.conf.skips = obj.skips;
+        changed = true;
+      }
+    }
+    if (typeof obj.duration === 'string' && obj.duration.length > 0) {
+      this.logger.conf.duration = obj.duration;
+      changed = true;
+    }
+    if (typeof obj.request === 'string') {
+      this.logger.conf.request = obj.request;
+      changed = true;
+    }
+    if (typeof obj.response === 'string') {
+      this.logger.conf.response = obj.response;
+      changed = true;
+    }
+    if (typeof obj.status === 'string') {
+      this.logger.conf.status = obj.status;
+      changed = true;
+    }
+    if (typeof obj.size === 'string') {
+      this.logger.conf.size = obj.size;
+      changed = true;
+    }
+    if (changed) {
+      return res.status(200).json(true).end();
+    } else {
+      return res.status(204).json(false).end();
+    }
+  }
+}
+export function isValidSkips(s: string[]): boolean {
+  for (const x of s) {
+    if (!(typeof x === 'string')) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/metadata.ts

@@ -1,9 +1,11 @@
-export type DataType = 'ObjectId' | 'date' | 'datetime' | 'time'
+export type Type = 'ObjectId' | 'date' | 'datetime' | 'time'
     | 'boolean' | 'number' | 'integer' | 'string' | 'text'
     | 'object' | 'array' | 'binary'
     | 'primitives' | 'booleans' | 'numbers' | 'integers' | 'strings' | 'dates' | 'datetimes' | 'times';
-export type FormatType = 'currency' | 'percentage' | 'email' | 'url' | 'phone' | 'fax' | 'ipv4' | 'ipv6';
+export type Format = 'currency' | 'percentage' | 'email' | 'url' | 'phone' | 'fax' | 'ipv4' | 'ipv6';
 
+export type DataType = Type;
+export type FormatType = Format;
 export interface ErrorMessage {
   field: string;
   code: string;
@@ -17,8 +19,8 @@ export interface Model {
 
 export interface Attribute {
   name?: string;
-  type?: DataType;
-  format?: FormatType;
+  type?: Type;
+  format?: Format;
   required?: boolean;
   key?: boolean;
   length?: number;

package/src/resources.ts

@@ -1,10 +1,63 @@
-import {Attributes, ErrorMessage} from './metadata';
+import { NextFunction, Request, Response } from 'express';
+import * as fs from 'fs';
+import { Attributes, ErrorMessage } from './metadata';
 
 // tslint:disable-next-line:class-name
 export class resources {
   static createValidator?: <T>(attributes: Attributes, allowUndefined?: boolean, max?: number) => Validator<T>;
+  static check: (obj: any, attributes: Attributes, allowUndefined?: boolean, patch?: boolean) => ErrorMessage[];
 }
 
 export interface Validator<T> {
   validate(obj: T, patch?: boolean): Promise<ErrorMessage[]>;
 }
+
+export class TypeChecker {
+  constructor(public attributes: Attributes, public allowUndefined?: boolean) {
+    this.check = this.check.bind(this);
+  }
+  check(req: Request, res: Response, next: NextFunction): void {
+    const obj = req.body;
+    if (!obj || (obj as any) === '') {
+      return res.status(400).end('The request body cannot be empty');
+    } else {
+      const errors = resources.check(obj, this.attributes, this.allowUndefined);
+      if (errors.length > 0) {
+        res.status(400).json(errors).end();
+      } else {
+        next();
+      }
+    }
+  }
+}
+export type Handler = (req: Request, res: Response, next: NextFunction) => void;
+export function check(attributes: Attributes, allowUndefined?: boolean): Handler {
+  const x = new TypeChecker(attributes, allowUndefined);
+  return x.check;
+}
+export interface Template {
+  name?: string | null;
+  text: string;
+  templates: TemplateNode[];
+}
+export interface TemplateNode {
+  type: string;
+  text: string;
+  property: string | null;
+  encode?: string | null;
+  value: string | null;
+}
+export function loadTemplates(ok: boolean|undefined, buildTemplates: (streams: string[], correct?: (stream: string) => string) => Map<string, Template>, correct?: (stream: string) => string, files?: string[]): Map<string, Template>|undefined {
+  if (!ok) {
+    return undefined;
+  }
+  if (!files) {
+    files = ['./src/query.xml'];
+  }
+  const mappers: string[] = [];
+  for (const file of files) {
+    const mapper = fs.readFileSync(file, 'utf8');
+    mappers.push(mapper);
+  }
+  return buildTemplates(mappers, correct);
+}

package/src/search.ts

@@ -107,30 +107,58 @@ export function initializeConfig(conf?: SearchConfig): SearchConfig | undefined
   }
   return c;
 }
-export function fromRequest<S>(req: Request, fields?: string, excluding?: string): S {
-  const s: any = (req.method === 'GET' ? fromUrl(req, fields, excluding) : req.body);
+export function fromRequest<S>(req: Request, arr?: string[]): S {
+  const s: any = (req.method === 'GET' ? fromUrl(req, arr) : req.body);
   return s;
 }
-export function fromUrl<S>(req: Request, fields?: string, excluding?: string): S {
+export function buildArray(arr?: string[], s0?: string, s1?: string, s2?: string): string[] {
+  const r: string[] = [];
+  if (arr && arr.length > 0) {
+    for (const a of arr) {
+      r.push(a);
+    }
+  }
+  if (s0 && s0.length > 0) {
+    r.push(s0);
+  }
+  if (s1 && s1.length > 0) {
+    r.push(s1);
+  }
+  if (s2 && s2.length > 0) {
+    r.push(s2);
+  }
+  return r;
+}
+export function fromUrl<S>(req: Request, arr?: string[]): S {
+  /*
   if (!fields || fields.length === 0) {
     fields = 'fields';
   }
+  */
   const s: any = {};
     const obj = req.query;
     const keys = Object.keys(obj);
     for (const key of keys) {
-      if (key === fields) {
+      if (inArray(key, arr)) {
         const x = (obj[key] as string).split(',');
-        s[key] = x;
-      } else if (key === excluding) {
-        const x = (obj[key] as string).split(',');
-        s[key] = x;
+        setValue(s, key, x);
       } else {
         setValue(s, key, obj[key] as string);
       }
     }
     return s;
 }
+export function inArray(s: string, arr?: string[]): boolean {
+  if (!arr || arr.length === 0) {
+    return false;
+  }
+  for (const a of arr) {
+    if (s === a) {
+      return true;
+    }
+  }
+  return false;
+}
 /*
 export function setValue<T>(obj: T, path: string, value: string): void {
   const paths = path.split('.');