@infrab4a/connect 5.7.2 → 5.7.3

package/src/infra/vertex-ai/adapters/vertex-axios.adapter.ts

@@ -0,0 +1,133 @@
+import axios, { AxiosRequestConfig } from 'axios'
+
+import { Product } from '../../../domain'
+import { DebugHelper } from '../../../utils'
+import { ProductBulk, ProductSearch } from '../types'
+import { VertexSearchConfig } from '../types/axios-vertex-search-config'
+
+import { VertexSearchAdapter } from './vertex-ai-search.adapter'
+
+export class VertexAxiosAdapter implements VertexSearchAdapter<ProductSearch> {
+  private logger: DebugHelper
+
+  constructor(private readonly config: VertexSearchConfig) {
+    this.logger = DebugHelper.from(this)
+  }
+
+  async query(term: string, total: number, gender?: String): Promise<ProductSearch[]> {
+    const logger = this.logger.with('query')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/search`,
+      method: 'POST',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+      data: { term, total, gender },
+    }
+
+    try {
+      const { data }: { data: ProductSearch[] } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  async get(id: string): Promise<ProductSearch> {
+    const logger = this.logger.with('update')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/${id}`,
+      method: 'GET',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+    }
+
+    try {
+      const { data } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  async save(data: Product) {
+    const logger = this.logger.with('save')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/sync`,
+      method: 'POST',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+      data,
+    }
+
+    try {
+      const { data } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  async update(id: string, data: Product) {
+    const logger = this.logger.with('update')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/${id}`,
+      method: 'PUT',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+      data,
+    }
+
+    try {
+      const { data } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    const logger = this.logger.with('delete')
+    const req: AxiosRequestConfig = {
+      url: `${this.config.url}/${id}`,
+      method: 'DELETE',
+      responseType: 'json',
+      headers: {
+        Accept: 'application/json',
+      },
+    }
+
+    try {
+      const { data } = await axios(req)
+
+      return data
+    } catch (error) {
+      logger.error({ req, res: error })
+
+      throw error
+    }
+  }
+
+  bulkProducts(_products: ProductBulk[]): Promise<void> {
+    return
+  }
+}

package/src/infra/vertex-ai/index.ts

@@ -0,0 +1,3 @@
+export * from './adapters'
+export * from './indexes'
+export * from './types'

package/src/infra/vertex-ai/indexes/index.ts

@@ -0,0 +1 @@
+export * from './products-vertex-search'

package/src/infra/vertex-ai/indexes/products-vertex-search.ts

@@ -0,0 +1,52 @@
+import { Product, ProductSearchIndex } from '../../../domain'
+import { omit } from '../../../utils'
+import { ProductHasuraGraphQL } from '../../hasura-graphql'
+import { VertexSearchAdapter } from '../adapters'
+import { ProductSearch } from '../types'
+
+export class ProductsVertexSearch implements ProductSearchIndex {
+  constructor(private readonly adapter: VertexSearchAdapter<ProductSearch>) {}
+
+  async getById(id: string): Promise<ProductSearch> {
+    const data = await this.adapter.get(id)
+
+    return data
+  }
+
+  async search<ProductSearch>(searchTerm: string, total: number, gender?: String): Promise<ProductSearch[]> {
+    try {
+      const result = await this.adapter.query(searchTerm, total, gender)
+
+      return result as ProductSearch[]
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  async save(product: ProductHasuraGraphQL): Promise<void> {
+    try {
+      const data = omit(product.toPlain(), ['createdAt', 'updatedAt', 'kitProducts'])
+      const newProduct = Product.toInstance(data)
+
+      await this.adapter.save(newProduct)
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  async update(product: ProductHasuraGraphQL) {
+    try {
+      await this.adapter.update(product.id, product)
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    try {
+      await this.adapter.delete(id)
+    } catch (error) {
+      console.error(error)
+    }
+  }
+}

package/src/infra/vertex-ai/types/axios-vertex-search-config.ts

@@ -0,0 +1,4 @@
+export type VertexSearchConfig = {
+  url: string
+  token?: string
+}

package/src/infra/vertex-ai/types/index.ts

@@ -0,0 +1,3 @@
+export * from './axios-vertex-search-config'
+export * from './product-bulk'
+export * from './product-search'

package/src/infra/vertex-ai/types/product-bulk.ts

@@ -0,0 +1,4 @@
+export type ProductBulk = {
+  id: string
+  jsonData: string
+}

package/src/infra/vertex-ai/types/product-search.ts

@@ -0,0 +1,21 @@
+export type ProductSearch = {
+  id: string
+  name: string
+  ean?: string
+  sku: string
+  icon?: string
+  miniatures?: string
+  description?: string
+  slug: string
+  brand: string
+  published: boolean
+  gender: string
+  shoppingCount: number
+  stock: number
+  rating: number
+  fullPrice: number
+  price: number
+  subscriberPrice: number
+  outlet: boolean
+  createdAt: Date
+}

package/src/utils/circular-dependencies.ts

@@ -0,0 +1,15 @@
+const registry = new Map<string, any>()
+
+export function registerClass(name: string, classConstructor: any): void {
+  registry.set(name, classConstructor)
+}
+
+export function getClass(name: string): any {
+  return registry.get(name)
+}
+
+export function resolveClass(name: string): () => any {
+  return () => {
+    return getClass(name)
+  }
+}

package/src/utils/decorators/debug.class.decorator.ts

@@ -0,0 +1,7 @@
+import { DebugDecoratorHelper, DebugOptions } from '../helpers'
+
+export function Debug(opts?: DebugOptions): ClassDecorator {
+  return function <TFunction>(target: any): TFunction | void {
+    DebugDecoratorHelper.set(target.prototype, opts)
+  }
+}

package/src/utils/decorators/index.ts

@@ -0,0 +1,2 @@
+export * from './debug.class.decorator'
+export * from './trace.method.decorator'

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'