@infrab4a/connect 5.0.0-alpha.8 → 6.0.0-alpha.0

package/src/utils/decorators/trace.method.decorator.ts

@@ -0,0 +1,119 @@
+import { get } from 'lodash'
+
+import { Debuggable, DebugHelper } from '../helpers'
+
+export type CallbackFnArgs<T, Result> = {
+  target: T
+  result: Result
+  args: Array<any>
+  namespace?: Array<string>
+}
+
+type CallbackFn<T, Result> = (opts: CallbackFnArgs<T, Result>) => void
+
+type TraceOptions<T, Result> = {
+  callbackFn?: CallbackFn<T, Result>
+  level?: 'trace' | 'log'
+}
+
+type Tracer<T, Result> = {
+  options: TraceOptions<T, Result>
+  method: any
+  target: T & Debuggable
+  propertyDescriptor: PropertyDescriptor
+  propertyKey: string
+}
+
+type CallTracerArgs = {
+  target: any
+  propertyKey: string
+  propertyDescriptor: PropertyDescriptor
+  args: Array<any>
+}
+
+const ASYNC_IDENTIFIER = 'async'
+
+export function Log<T, Result>(options: TraceOptions<T, Result> = {}) {
+  return Trace<T, Result>({ level: 'log', ...options })
+}
+
+export function Trace<T, Result>(options: TraceOptions<T, Result> = {}) {
+  return function(target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) {
+    const method = propertyDescriptor.value
+    const isPromise = method.toString().includes(ASYNC_IDENTIFIER)
+    const args = {
+      options,
+      method,
+      target,
+      propertyKey,
+      propertyDescriptor,
+    }
+
+    propertyDescriptor.value = isPromise ? promiseTracer(args) : functionTracer(args)
+
+    return propertyDescriptor
+  }
+}
+
+const traceCall = function({ target, propertyKey, propertyDescriptor, args }: CallTracerArgs): DebugHelper {
+  if (!target.debug) target.debug = DebugHelper.for(target, propertyKey)
+
+  return target.debug.push(propertyKey).trace('called', { target, propertyKey, propertyDescriptor, args })
+}
+
+const promiseTracer = function <T, Result>({ options, method, propertyKey, propertyDescriptor }: Tracer<T, Result>) {
+  return function(this: any, ...args: Array<any>): any {
+    return new Promise((resolve, reject) => {
+      const debug = traceCall({ target: this, propertyDescriptor, propertyKey, args })
+
+      return method
+        .apply(this, args)
+        .then((result: any) => {
+          if (options.callbackFn) {
+            options.callbackFn({ target: this, result, args, namespace: [propertyKey] })
+          }
+
+          if (get(options, 'level', '') === 'log') {
+            debug.log({ req: args, res: result === undefined ? 'void' : result })
+          }
+
+          return resolve(result)
+        })
+        .catch((error: Error) => {
+          debug.error({ req: args, res: error, stack: error.stack })
+
+          return reject(error)
+        })
+    })
+  }
+}
+
+const functionTracer = function <T, Result>({
+  options,
+  target,
+  method,
+  propertyKey,
+  propertyDescriptor,
+}: Tracer<T, Result>) {
+  return function(this: any, ...args: Array<any>): any {
+    const debug = traceCall({ target: this || target, propertyDescriptor, propertyKey, args })
+
+    let result: any
+
+    try {
+      result = method.apply(this, args)
+
+      if (options.callbackFn) options.callbackFn({ target: this, result, args, namespace: [propertyKey] })
+
+      if (get(options, 'level', '') === 'log') {
+        debug.log({ req: args, res: result === undefined ? 'void' : result })
+      }
+
+      return result
+    } catch (error) {
+      if (error instanceof Error) debug.error({ req: args, res: error, stack: error.stack })
+
+      throw error
+    }
+  }
+}

package/src/utils/get.ts

@@ -0,0 +1,3 @@
+import { get as getLodash } from 'lodash'
+
+export const get = (object: any, path: string, defaultValue?: any) => getLodash(object, path, defaultValue)

package/src/utils/helpers/class-name.helper.ts

@@ -0,0 +1,16 @@
+import { compact, get } from 'lodash'
+
+export class ClassNameHelper {
+  static get(clazz: any): string {
+    if (!clazz) return null
+
+    const prototype = Object.getPrototypeOf(clazz)
+    const names = compact([
+      get(clazz, 'constructor.name'),
+      get(prototype, 'constructor.name'),
+      get(prototype, '__proto__.constructor.name'),
+    ])
+
+    return names.find((name) => name !== 'class_1')
+  }
+}

package/src/utils/helpers/debug-decorator.helper.ts

@@ -0,0 +1,25 @@
+import { ReflectHelper } from './reflect.helper'
+
+export type DebugOptions = {
+  name?: string
+  namespaces?: Array<string>
+}
+
+export class DebugDecoratorHelper {
+  static DebugNamingMetadataKey = 'model:naming:decorator'
+
+  static set(target: object, options: DebugOptions): void {
+    ReflectHelper.add<DebugOptions>({
+      key: DebugDecoratorHelper.DebugNamingMetadataKey,
+      target,
+      value: options,
+    })
+  }
+
+  static get(target: object): DebugOptions {
+    return ReflectHelper.first<DebugOptions>({
+      key: DebugDecoratorHelper.DebugNamingMetadataKey,
+      target,
+    })
+  }
+}

package/src/utils/helpers/debug.helper.ts

@@ -0,0 +1,222 @@
+import { Debugger } from 'debug'
+import { compact, flatten, get, isNil } from 'lodash'
+
+import { DebugNamespaces, Logger } from '../log.utils'
+import { ObsEmitter } from '../obs-emitter'
+
+import { ClassNameHelper } from './class-name.helper'
+import { DebugDecoratorHelper } from './debug-decorator.helper'
+
+export type Debuggable = {
+  debug: DebugHelper
+}
+
+type DebugLog = {
+  namespace: string
+  message: string
+  args: Array<any>
+}
+
+type DebugError = {
+  namespace: string
+  error: any
+  args: Array<any>
+}
+
+export const isDebuggable = (object: any): object is Debuggable => {
+  return 'debug' in object
+}
+
+export class DebugHelper {
+  static logs$ = new ObsEmitter<DebugLog>()
+  static traces$ = new ObsEmitter<DebugLog>()
+  static errors$ = new ObsEmitter<DebugError>()
+  static isDebuggable = isDebuggable
+
+  logger: Debugger
+  tracer: Debugger
+  err: Debugger
+  namespaces: Set<string>
+
+  static namespacesFor(target: object): Array<string> {
+    if (isNil(target)) return []
+
+    const decorator = DebugDecoratorHelper.get(Object.getPrototypeOf(target))
+    const namespaces = get(decorator, 'namespaces', [])
+    const name = get(decorator, 'name', ClassNameHelper.get(target))
+
+    return [...namespaces, name]
+  }
+
+  static as(...namespaces: Array<string>): DebugHelper {
+    return new DebugHelper(...namespaces)
+  }
+
+  static for(target: object, ...namespaces: Array<string>): DebugHelper {
+    const targetNamespaces = this.namespacesFor(target)
+
+    return new DebugHelper(...targetNamespaces, ...namespaces)
+  }
+
+  static from(target: object, ...namespaces: Array<string>): DebugHelper {
+    if (this.isDebuggable(target)) {
+      const debug = target.debug
+
+      if (namespaces) debug.push(...namespaces)
+
+      return debug
+    }
+
+    return DebugHelper.for(target, ...namespaces)
+  }
+
+  static clonedFrom(target: object, ...namespaces: Array<string>): DebugHelper {
+    if (this.isDebuggable(target)) {
+      namespaces.push(...target.debug.entries)
+    } else if (!isNil(target)) {
+      namespaces.push(...this.namespacesFor(target))
+    }
+
+    return DebugHelper.for(target, ...namespaces)
+  }
+
+  static clone(target: object, ...namespaces: Array<string>): { original: DebugHelper; debug: DebugHelper } {
+    let original: DebugHelper
+
+    if (this.isDebuggable(target)) {
+      original = target.debug
+      namespaces.push(...original.entries)
+    }
+
+    return {
+      original,
+      debug: DebugHelper.for(target, ...namespaces),
+    }
+  }
+
+  static replace(target: any, attrs: { with: DebugHelper }): void {
+    if (this.isDebuggable(target)) target.debug = attrs.with
+  }
+
+  static mock(target: object, ...namespaces: Array<string>): { original: DebugHelper; debug: DebugHelper } {
+    const { original, debug } = DebugHelper.clone(target, ...namespaces)
+
+    DebugHelper.replace(target, { with: debug })
+
+    return { original, debug }
+  }
+
+  constructor(...namespace: Array<string>) {
+    this.namespaces = new Set<string>()
+    this.push(...namespace)
+  }
+
+  get entries(): Array<string> {
+    return Array.from(get(this, 'namespaces', []))
+  }
+
+  get namespace(): string {
+    return compact(flatten(this.entries)).join(':')
+  }
+
+  log(message?: any, ...args: Array<any>): DebugHelper {
+    this.logger(JSON.stringify(message), ...args.map((element) => JSON.stringify(element)))
+    DebugHelper.logs$.next({ namespace: this.namespace, message, args })
+
+    return this
+  }
+
+  trace(message?: any, ...args: Array<any>): DebugHelper {
+    this.logger.extend(DebugNamespaces.TRACE)(message, ...args)
+    DebugHelper.traces$.next({ namespace: this.namespace, message, args })
+
+    return this
+  }
+
+  error(error: any, ...args: Array<any>): DebugHelper {
+    this.logger.extend(DebugNamespaces.ERROR)(JSON.stringify(error), ...args.map((element) => JSON.stringify(element)))
+    DebugHelper.errors$.next({ namespace: this.namespace, error, args })
+
+    return this
+  }
+
+  build(): DebugHelper {
+    this.logger = Logger
+    this.tracer = Logger
+    this.err = Logger
+
+    this.entries.forEach((namespace) => {
+      this.logger = this.logger.extend(namespace)
+      this.tracer = this.tracer.extend(namespace)
+      this.err = this.err.extend(namespace)
+    })
+
+    return this
+  }
+
+  with(...namespace: Array<string>): DebugHelper {
+    return new DebugHelper(...this.entries, ...namespace)
+  }
+
+  push(...namespace: Array<string>): DebugHelper {
+    if (namespace) {
+      namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.add(item))
+    }
+
+    return this.build()
+  }
+
+  unshift(...namespace: Array<string>): DebugHelper {
+    if (namespace) {
+      return this.reset(...namespace, ...this.entries)
+    }
+
+    return this
+  }
+
+  reset(...namespace: Array<string>): DebugHelper {
+    this.namespaces = new Set(flatten(compact(namespace)))
+
+    return this.build()
+  }
+
+  startWith(...namespace: Array<string>): DebugHelper {
+    const current = this.namespaces
+
+    this.namespaces = new Set(flatten([compact(namespace), ...current]))
+
+    return this.build()
+  }
+
+  shift(): DebugHelper {
+    const list = this.entries
+
+    list.shift()
+
+    return this.reset(...list)
+  }
+
+  pop(): DebugHelper {
+    const list = this.entries
+
+    list.pop()
+
+    return this.reset(...list)
+  }
+
+  clear(): DebugHelper {
+    return this.reset()
+  }
+
+  remove(...namespace: Array<string>): DebugHelper {
+    if (namespace) {
+      namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.delete(item))
+    }
+
+    return this.build()
+  }
+
+  puts(...args: Array<string>): string {
+    return [`[${this.namespace}]`, ...args].join(' ')
+  }
+}

package/src/utils/helpers/index.ts

@@ -0,0 +1,4 @@
+export * from './debug.helper'
+export * from './reflect.helper'
+export * from './class-name.helper'
+export * from './debug-decorator.helper'

package/src/utils/helpers/reflect.helper.ts

@@ -0,0 +1,216 @@
+import { first, flatten, isArray, isNil, last } from 'lodash'
+import 'reflect-metadata'
+
+type Dictionary<T> = {
+  [key: string]: T
+}
+export type MetaArgs = {
+  key: keyof MetaStorage | string
+  target: any
+  property?: string | symbol
+  own?: boolean
+  propertyDescriptor?: PropertyDescriptor
+}
+export type MetaValueArgs<T = any> = MetaArgs & {
+  value: T
+}
+type MetaProperties<T = any> = Dictionary<T>
+type MetaTargets = Dictionary<MetaProperties>
+type MetaKeys = Dictionary<MetaTargets>
+type MetaStorage = {
+  value?: any
+  object?: any
+  values?: MetaKeys
+} & Record<string, any>
+
+export class ReflectHelper {
+  private static _items: MetaStorage = {}
+
+  static get items(): MetaStorage {
+    return this._items
+  }
+
+  static get keys(): Array<string> {
+    return Object.keys(ReflectHelper.items)
+  }
+
+  static has(key: keyof MetaStorage, target?: any, property?: string | symbol): boolean {
+    return (
+      !isNil(key) &&
+      !isNil(ReflectHelper.items[key]) &&
+      (isNil(target) ||
+        (!isNil(ReflectHelper.items[key][target]) &&
+          (isNil(property) || !isNil(ReflectHelper.items[key][target][String(property)]))))
+    )
+  }
+
+  static get<T = any>({ key, target, property, own = true }: MetaArgs): Array<T> {
+    try {
+      if (own) {
+        return Reflect.getOwnMetadata(key, target, property) || null
+      } else {
+        return Reflect.getMetadata(key, target, property) || null
+      }
+    } catch {
+      return null
+    }
+  }
+
+  static first<T = any>({ key, target, property, own = true }: MetaArgs): T {
+    const values = ReflectHelper.get<T>({ key, target, property, own })
+
+    return isArray(values) ? first(values) : values
+  }
+
+  static last<T = any>({ key, target, property, own = true }: MetaArgs): T {
+    const values = ReflectHelper.get<T>({ key, target, property, own })
+
+    return isArray(values) ? last(values) : values
+  }
+
+  static set<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {
+    Reflect.defineMetadata(key, value, target, property)
+
+    ReflectHelper.put<T>({ key, target, property, value, propertyDescriptor })
+  }
+
+  static add<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {
+    let values: Array<T> = ReflectHelper.get<T>({ key, target, property }) || new Array<T>()
+
+    if (!Array.isArray(values)) values = [values]
+
+    values.push(value)
+
+    ReflectHelper.set<Array<T>>({ key, target, property, value: values, propertyDescriptor })
+  }
+
+  static all<T = any>({ key }: Partial<MetaArgs>): Array<MetaValueArgs<T>> {
+    const items = ReflectHelper.items[key] || {}
+
+    return flatten(Object.keys(items).map((item) => flatten(this.allFrom(key, items[item]))))
+  }
+
+  static allFrom(key: string, target: any): any {
+    return Object.keys(target)
+      .filter((property) => property !== 'object')
+      .map((property) => this.allValuesFrom(key, target, property))
+  }
+
+  static allValuesFrom(key: string, target: any, property: any): any {
+    const values = target[property]
+    let value = values.value
+    const propertyDescriptor = values.propertyDescriptor
+
+    if (!isArray(value)) value = [value]
+
+    return flatten(
+      value.map((val: any) => {
+        return {
+          key,
+          target: target.object,
+          property,
+          value: val,
+          propertyDescriptor,
+        }
+      }),
+    )
+  }
+
+  static delete({ key, target, property }: MetaArgs): boolean {
+    Reflect.deleteMetadata(key, target, property)
+
+    return ReflectHelper.remove(key, target, property)
+  }
+
+  static clear(key?: string): void {
+    if (!key) {
+      ReflectHelper.keys.forEach((storedKey) => {
+        ReflectHelper.clear(storedKey)
+      })
+    } else {
+      if (ReflectHelper.keys.includes(key)) {
+        Object.values<MetaStorage>(ReflectHelper.items[key]).forEach((target) => {
+          if (ReflectHelper.has(key, target)) {
+            Object.values(ReflectHelper.items[key][target.toString()]).forEach((property) => {
+              ReflectHelper.delete({
+                key,
+                target: target.object,
+                property: String(property),
+              })
+              ReflectHelper.remove(key, target, String(property))
+            })
+          }
+
+          ReflectHelper.delete({ key, target: target.object })
+          ReflectHelper.remove(key, target)
+        })
+      }
+    }
+  }
+
+  static getType({ target, propertyKey }: { target: string; propertyKey: string }): any {
+    return Reflect.getMetadata('design:type', target, propertyKey)
+  }
+
+  static getReturntype({ target, propertyKey }: { target: string; propertyKey: string }): any {
+    return Reflect.getMetadata('design:returntype', target, propertyKey)
+  }
+
+  static getAllMethods(target: any): string[] {
+    const props = []
+    let obj = target
+
+    do {
+      props.push(...Object.getOwnPropertyNames(obj))
+    } while ((obj = Object.getPrototypeOf(obj)))
+
+    return props.sort().filter((e, i, arr) => {
+      if (
+        [
+          '__defineGetter__',
+          '__defineSetter__',
+          '__lookupGetter__',
+          '__lookupSetter__',
+          'constructor',
+          'hasOwnProperty',
+          'isPrototypeOf',
+          'propertyIsEnumerable',
+          'toLocaleString',
+          'toString',
+          'valueOf',
+        ].includes(e)
+      )
+        return false
+
+      if (e != arr[i + 1] && typeof target[e] === 'function') return true
+    })
+  }
+
+  private static put<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {
+    const index = target.constructor.name
+
+    ReflectHelper.items[key] = ReflectHelper.items[key] || {}
+    ReflectHelper.items[key][index] = ReflectHelper.items[key][index] || {}
+    ReflectHelper.items[key][index].object = target
+
+    if (isNil(property)) {
+      ReflectHelper.items[key][index].value = {
+        value,
+        propertyDescriptor,
+      }
+    } else {
+      ReflectHelper.items[key][index][String(property)] = ReflectHelper.items[key][index][String(property)] || {}
+      ReflectHelper.items[key][index][String(property)] = {
+        value,
+        propertyDescriptor,
+      }
+    }
+  }
+
+  private static remove(key: string, target?: any, property?: string | symbol): boolean {
+    if (ReflectHelper.has(key, target, property)) return delete ReflectHelper.items[key][target][String(property)]
+    else if (ReflectHelper.has(key, target)) return delete ReflectHelper.items[key][target]
+    else if (ReflectHelper.has(key)) return delete ReflectHelper.items[key]
+    else return false
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,82 @@
+import {
+  add,
+  addBusinessDays,
+  addDays,
+  addMonths,
+  addYears,
+  Duration,
+  endOfDay,
+  format,
+  formatISO9075,
+  parseISO,
+  startOfDay,
+  sub,
+  subDays,
+} from 'date-fns'
+import {
+  chunk,
+  each,
+  get,
+  isBoolean,
+  isDate,
+  isEmpty,
+  isInteger,
+  isNaN,
+  isNil,
+  isNumber,
+  isObject,
+  isString,
+  now,
+  omit,
+  pick,
+  set,
+  sortBy,
+  unset,
+} from 'lodash'
+
+export type DateDuration = Duration
+
+export * from './circular-dependencies'
+export * from './decorators'
+export * from './get'
+export * from './helpers'
+export * from './is'
+export * from './is-uuid'
+export * from './log.utils'
+export * from './mixins'
+export * from './obs-emitter'
+export * from './parse-datetime'
+export * from './serialize'
+export * from './types'
+export {
+  add,
+  addBusinessDays,
+  addDays,
+  addMonths,
+  addYears,
+  chunk,
+  each,
+  endOfDay,
+  format,
+  formatISO9075,
+  get,
+  isBoolean,
+  isDate,
+  isEmpty,
+  isInteger,
+  isNaN,
+  isNil,
+  isNumber,
+  isObject,
+  isString,
+  now,
+  omit,
+  parseISO,
+  pick,
+  set,
+  sortBy,
+  startOfDay,
+  sub,
+  subDays,
+  unset,
+}

package/src/utils/is-uuid.ts

@@ -0,0 +1,4 @@
+import { isString } from 'lodash'
+
+export const isUUID = (value: string): boolean =>
+  isString(value) && /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/.test(value)

package/src/utils/is.ts

@@ -0,0 +1,3 @@
+export function is<T>(value: any): T {
+  return value
+}