core-express 0.1.0 → 0.1.1

package/src/log.ts

@@ -0,0 +1,245 @@
+import { NextFunction, Request, Response } from "express"
+import { PassThrough } from "stream"
+import { resources } from "./resources"
+
+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, m: SimpleMap) => SimpleMap) {
+    this.log = this.log.bind(this)
+    this.conf = createConfig(conf)
+  }
+  conf: MiddleLog
+  log(req: Request, res: Response, 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(resources.encoding)
+          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, 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
+}
+
+// tslint:disable-next-line:max-classes-per-file
+export class MiddlewareController {
+  constructor(public logger: Middleware) {
+    this.config = this.config.bind(this)
+  }
+  config(req: Request, res: Response) {
+    const obj: MiddleLog = req.body
+    if (!this.logger) {
+      res.status(503).end("Logger is not available")
+      return
+    }
+    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) {
+      res.status(200).json(true).end()
+    } else {
+      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
+}
+export function mask(s: string, start: number, end: number, replace: string): string {
+  if (start < 0) {
+    start = 0
+  }
+  if (end < 0) {
+    end = 0
+  }
+  const t = start + end
+  if (t >= s.length) {
+    return replace.repeat(s.length)
+  }
+  return s.substr(0, start) + replace.repeat(s.length - t) + s.substr(s.length - end)
+}
+export function margin(s: string, start: number, end: number, replace: string): string {
+  if (start >= end) {
+    return ""
+  }
+  if (start < 0) {
+    start = 0
+  }
+  if (end < 0) {
+    end = 0
+  }
+  if (start >= s.length) {
+    return replace.repeat(s.length)
+  }
+  if (end >= s.length) {
+    return replace.repeat(start) + s.substr(start)
+  }
+  return replace.repeat(start) + s.substr(start, end - start) + replace.repeat(s.length - end)
+}
+export const maskMargin = margin

package/src/metadata.ts

@@ -1,34 +1,45 @@
-export type DataType = 'ObjectId' | 'date' | 'datetime' | 'time'
-    | 'boolean' | 'number' | 'integer' | 'string' | 'text'
-    | 'object' | 'array' | 'primitives' | 'binary';
-export type FormatType = 'currency' | 'percentage' | 'email' | 'url' | 'phone' | 'fax' | 'ipv4' | 'ipv6';
+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 Format = "currency" | "percentage" | "email" | "url" | "phone" | "fax" | "ipv4" | "ipv6"
 
+export type DataType = Type
+export type FormatType = Format
 export interface ErrorMessage {
-  field: string;
-  code: string;
-  param?: string|number|Date;
-  message?: string;
+  field: string
+  code: string
+  message?: string
+  param?: string | number | Date
+  invalid?: string
 }
 
 export interface Model {
-  attributes: Attributes;
+  attributes: Attributes
 }
 
 export interface Attribute {
-  name?: string;
-  type?: DataType;
-  format?: FormatType;
-  required?: boolean;
-  key?: boolean;
-  length?: number;
-  min?: number;
-  max?: number;
-  gt?: number;
-  lt?: number;
-  exp?: RegExp|string;
-  code?: string;
-  typeof?: Model;
+  name?: string
+  type?: Type
+  key?: boolean
 }
 export interface Attributes {
-  [key: string]: Attribute;
+  [key: string]: Attribute
 }

package/src/resources.ts

@@ -1,10 +1,149 @@
-import {Attributes, ErrorMessage} from './metadata';
+import { Application, NextFunction, Request, Response } from "express"
+import * as fs from "fs"
+import * as http from "http"
+import * as https from "https"
+import { Attributes, ErrorMessage } from "./metadata"
 
+export interface StringMap {
+  [key: string]: string
+}
 // tslint:disable-next-line:class-name
 export class resources {
-  static createValidator?: <T>(attributes: Attributes, allowUndefined?: boolean, max?: number) => Validator<T>;
+  static languageParam = "lang"
+  static defaultLanguage = "en"
+  static limits = [12, 24, 60, 100, 120, 180, 300, 600]
+  static pages = "pages"
+  static page = "page"
+  static nextPageToken = "next"
+  static limit = "limit"
+  static defaultLimit = 12
+  static sort = "sort"
+  static fields = "fields"
+  static partial = "partial"
+  static subPartial = "sub"
+  static log?: (msg: string) => void
+  static returnServerError?: boolean
+  static createValidator?: <T>(attributes: Attributes, allowUndefined?: boolean, max?: number) => Validator<T>
+  static check: (obj: any, attributes: Attributes, allowUndefined?: boolean, patch?: boolean) => ErrorMessage[]
+  static encoding?: BufferEncoding = "utf-8"
+}
+export function getView(req: Request, view: string): string {
+  const partial = req.query[resources.partial]
+  return partial === "true" ? resources.pages + "/" + view : view
+}
+export function isPartial(req: Request): boolean {
+  return req.query[resources.partial] === "true"
+}
+export function isSubPartial(req: Request): boolean {
+  return req.query[resources.subPartial] === "true"
 }
-
 export interface Validator<T> {
-  validate(obj: T, patch?: boolean): Promise<ErrorMessage[]>;
+  validate(obj: T, resource?: StringMap, patch?: boolean): Promise<ErrorMessage[]>
+}
+
+// tslint:disable-next-line:max-classes-per-file
+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) === "") {
+      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 Parameter {
+  name: string
+  type: string
+}
+export interface StringFormat {
+  texts: string[]
+  parameters: Parameter[]
+}
+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
+  format: StringFormat
+  array?: string | null
+  separator?: string | null
+  suffix?: string | null
+  prefix?: 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)
+}
+export interface Server {
+  port: number
+  https?: boolean
+  options?: any
+  key?: string
+  cert?: string
+}
+export function start(a: Application, s: Server): void {
+  process.on("uncaughtException", (err) => {
+    console.log(err)
+  })
+  if (s.https) {
+    if (s.options) {
+      https.createServer(s.options, a).listen(s.port, () => {
+        console.log("Use https and start server at port " + s.port)
+      })
+    } else if (s.key && s.cert && s.key.length > 0 && s.cert.length > 0) {
+      const options = {
+        key: fs.readFileSync(s.key),
+        cert: fs.readFileSync(s.cert),
+      }
+      https.createServer(options, a).listen(s.port, () => {
+        console.log("Use https and start server at port " + s.port)
+      })
+    } else {
+      http.createServer(a).listen(s.port, () => {
+        console.log("Start server at port " + s.port)
+      })
+    }
+  } else {
+    http.createServer(a).listen(s.port, () => {
+      console.log("Start server at port " + s.port)
+    })
+  }
 }