@infrab4a/connect 6.0.0-alpha.0 → 6.0.0-alpha.1

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

@@ -1,119 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,216 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

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