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

package/src/infra/hasura-graphql/mixins/helpers/create/hasura-column.helper.ts

@@ -0,0 +1,49 @@
+import { ModelBaseStructure } from '../../../../../domain'
+import { HasuraGraphQLFields } from '../../../types'
+import { AttributeOptionHelper } from '../attribute-option.helper'
+
+export class HasuraColumnHelper {
+  static extractPrimaryKeyColumns<MBase extends ModelBaseStructure<MBase>>(
+    model: any,
+    fields: HasuraGraphQLFields<MBase>,
+  ): HasuraGraphQLFields<MBase> {
+    return model.identifiersFields.map(
+      (field: any) => AttributeOptionHelper.FindByAttribute(field, fields).columnName,
+    ) as HasuraGraphQLFields<MBase>
+  }
+
+  static extractForeignKeyColumns<MBase extends ModelBaseStructure<MBase>>(fields: HasuraGraphQLFields<MBase>): any[] {
+    return fields
+      .map((field) => {
+        const columnOptions = Object.values(field).shift()
+
+        return (
+          AttributeOptionHelper.CheckIsColumnOption(columnOptions) &&
+          columnOptions.foreignKeyColumn && [
+            ...Object.values(columnOptions.foreignKeyColumn).map(
+              (foreignKeyName) => AttributeOptionHelper.FindByAttribute(foreignKeyName as any, fields)?.columnName,
+            ),
+            {
+              [columnOptions.columnName]: Object.keys(columnOptions.foreignKeyColumn).map(
+                (foreignKeyField) =>
+                  AttributeOptionHelper.FindByAttribute(foreignKeyField as any, columnOptions?.fields as any)
+                    ?.columnName || foreignKeyField,
+              ),
+            },
+          ]
+        )
+      })
+      .filter(Boolean)
+      .reduce((keys, current) => [...keys, ...current], [])
+  }
+
+  static buildQueryColumns<MBase extends ModelBaseStructure<MBase>>(
+    model: any,
+    fields: HasuraGraphQLFields<MBase>,
+  ): HasuraGraphQLFields<MBase> {
+    const primaryKeyColumns = this.extractPrimaryKeyColumns(model, fields)
+    const foreignKeyColumns = this.extractForeignKeyColumns(fields)
+
+    return [...primaryKeyColumns, ...foreignKeyColumns] as HasuraGraphQLFields<MBase>
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/create/hasura-create-operations.helper.ts

@@ -0,0 +1,62 @@
+import { BaseModelBuilder, CreateRepositoryParams, ModelBaseStructure } from '../../../../../domain'
+import { DebugHelper } from '../../../../../utils'
+import { GraphQLRepository, HasuraGraphQLFields } from '../../../types'
+
+import { HasuraColumnHelper } from './hasura-column.helper'
+
+export type ExecuteCreateParams<MBase extends ModelBaseStructure<MBase>> = {
+  data: MBase
+  repository: GraphQLRepository<MBase>
+  insertGraphQLOperation: string
+  insertGraphQLObjectType: string
+  fields: HasuraGraphQLFields<MBase>
+  model: BaseModelBuilder<MBase>
+}
+
+export class HasuraCreateOperationsHelper {
+  static buildInsertOperationName(tableName: string, customOperation?: string): string {
+    return customOperation || `insert_${tableName}_one`
+  }
+
+  static buildInsertObjectType(tableName: string, customObjectType?: string): string {
+    return customObjectType || `${tableName}_insert_input`
+  }
+
+  static async executeCreate<MBase extends ModelBaseStructure<MBase>>(
+    data: CreateRepositoryParams<MBase>,
+    params: Omit<ExecuteCreateParams<MBase>, 'data'>,
+  ): Promise<MBase> {
+    const { model } = params
+
+    params.repository.logger = DebugHelper.from(params.repository, 'create')
+
+    const instance = model.toInstance(data)
+    const newData = await this.executeSave({ ...params, data: instance })
+
+    return model.toInstance(newData)
+  }
+
+  static async executeSave<MBase extends ModelBaseStructure<MBase>>(
+    params: ExecuteCreateParams<MBase>,
+  ): Promise<Partial<MBase>> {
+    const { data, repository, insertGraphQLOperation, insertGraphQLObjectType, fields, model } = params
+
+    const queryColumns = HasuraColumnHelper.buildQueryColumns(model, fields)
+
+    const result = await repository.mutation<Record<string, Record<string, any>>>(
+      insertGraphQLOperation,
+      queryColumns,
+      {
+        object: {
+          type: insertGraphQLObjectType,
+          required: true,
+          value: repository.convertDataToHasura(data),
+        },
+      },
+    )
+
+    const convertedResult = repository.convertDataFromHasura(result[insertGraphQLOperation])
+
+    return { ...data.toPlain(), ...convertedResult.toPlain() }
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/create/index.ts

@@ -0,0 +1,2 @@
+export { HasuraColumnHelper } from './hasura-column.helper'
+export { ExecuteCreateParams, HasuraCreateOperationsHelper } from './hasura-create-operations.helper'

package/src/infra/hasura-graphql/mixins/helpers/delete/hasura-cache-operations.helper.ts

@@ -0,0 +1,23 @@
+import { CacheConfig, ModelBaseStructure } from '../../../../../domain'
+import { DebugHelper } from '../../../../../utils'
+import { CacheKeyGeneratorHelper } from '../cache-key-generator.helper'
+
+export class HasuraCacheOperationsHelper {
+  static async removeCacheData<MBase extends ModelBaseStructure<MBase>>(
+    cache: CacheConfig | undefined,
+    params: {
+      model: any
+      identifiers: any
+      logger: DebugHelper
+    },
+  ): Promise<void> {
+    const { model, identifiers, logger } = params
+
+    if (!cache?.cacheAdapter) return
+
+    const cacheKey = CacheKeyGeneratorHelper.generateCacheKeyFromIdentifiers(model, identifiers)
+
+    await cache.cacheAdapter.remove(cacheKey)
+    logger.log(`Cache removido: ${cacheKey}`)
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/delete/hasura-delete-operations.helper.ts

@@ -0,0 +1,51 @@
+import { CacheConfig, DeleteRepositoryParams, ModelBaseStructure } from '../../../../../domain'
+import { DebugHelper } from '../../../../../utils'
+import { GraphQLRepository, HasuraGraphQLFields } from '../../../types'
+
+import { HasuraCacheOperationsHelper } from './hasura-cache-operations.helper'
+import { HasuraDeleteVariablesHelper } from './hasura-delete-variables.helper'
+
+export type ExecuteDeleteParams<MBase extends ModelBaseStructure<MBase>> = {
+  identifiers: DeleteRepositoryParams<MBase>
+  repository: GraphQLRepository<MBase>
+  deleteGraphQLOperation: string
+  fields: HasuraGraphQLFields<MBase>
+  model: any
+  cache?: CacheConfig
+}
+
+export class HasuraDeleteOperationsHelper {
+  static buildDeleteOperationName(tableName: string, customOperation?: string): string {
+    return customOperation || `delete_${tableName}_by_pk`
+  }
+
+  static async executeDelete<MBase extends ModelBaseStructure<MBase>>(
+    params: ExecuteDeleteParams<MBase>,
+  ): Promise<void> {
+    const { identifiers, repository, deleteGraphQLOperation, fields, model, cache } = params
+
+    const logger = DebugHelper.from(repository, 'delete')
+
+    await this.handleCacheRemoval(cache, { model, identifiers, logger })
+
+    const identifierColumns = HasuraDeleteVariablesHelper.buildDeleteIdentifierColumns(model, fields)
+    const variables = HasuraDeleteVariablesHelper.buildDeleteVariables(identifiers, {
+      model,
+      fields,
+      repository,
+    })
+
+    await repository.mutation(deleteGraphQLOperation, identifierColumns, variables)
+  }
+
+  private static async handleCacheRemoval<MBase extends ModelBaseStructure<MBase>>(
+    cache: CacheConfig | undefined,
+    params: {
+      model: any
+      identifiers: DeleteRepositoryParams<MBase>
+      logger: DebugHelper
+    },
+  ): Promise<void> {
+    await HasuraCacheOperationsHelper.removeCacheData(cache, params)
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/delete/hasura-delete-variables.helper.ts

@@ -0,0 +1,54 @@
+import {
+  DeleteRepositoryParams,
+  ModelBaseStructure,
+  NonFunctionAndIdentifierPropertyNames,
+} from '../../../../../domain'
+import { isNil } from '../../../../../utils'
+import { GraphQLRepository, HasuraGraphQLFields } from '../../../types'
+import { AttributeOptionHelper } from '../attribute-option.helper'
+
+export class HasuraDeleteVariablesHelper {
+  static buildDeleteIdentifierColumns<MBase extends ModelBaseStructure<MBase>>(
+    model: any,
+    fields: HasuraGraphQLFields<MBase>,
+  ): HasuraGraphQLFields<MBase> {
+    return model.identifiersFields.map(
+      (field: any) => AttributeOptionHelper.FindByAttribute(field, fields).columnName,
+    ) as HasuraGraphQLFields<MBase>
+  }
+
+  static buildDeleteVariables<MBase extends ModelBaseStructure<MBase>>(
+    identifiers: DeleteRepositoryParams<MBase>,
+    params: {
+      model: any
+      fields: HasuraGraphQLFields<MBase>
+      repository: GraphQLRepository<MBase>
+    },
+  ): Record<string, any> {
+    const { model, fields, repository } = params
+    const instance = model.toInstance(identifiers)
+
+    return model.identifiersFields.reduce((ids: any, identifier: any) => {
+      const identifierBinded: Extract<
+        NonFunctionAndIdentifierPropertyNames<MBase>,
+        MBase['identifiersFields'][number]
+      > = identifier
+
+      if (isNil(instance.identifier[identifierBinded])) return ids
+
+      const columnOption = AttributeOptionHelper.FindByAttribute(identifier, fields)
+      const value =
+        columnOption?.to(identifiers[identifier as keyof DeleteRepositoryParams<MBase>], instance) ||
+        identifiers[identifier as keyof DeleteRepositoryParams<MBase>]
+
+      return {
+        ...ids,
+        [columnOption.columnName]: {
+          type: repository.getAttributeGraphQLTypeOf(columnOption.type || value),
+          value,
+          required: true,
+        },
+      }
+    }, {})
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/delete/index.ts

@@ -0,0 +1,3 @@
+export { HasuraCacheOperationsHelper } from './hasura-cache-operations.helper'
+export { ExecuteDeleteParams, HasuraDeleteOperationsHelper } from './hasura-delete-operations.helper'
+export { HasuraDeleteVariablesHelper } from './hasura-delete-variables.helper'

package/src/infra/hasura-graphql/mixins/helpers/filter-option.helper.ts

@@ -0,0 +1,76 @@
+import { ModelBaseStructure, RepositoryFindFieltersOptions, Where } from '../../../../domain'
+import { isNil } from '../../../../utils'
+import { ColumnOptions } from '../../types'
+
+export class FilterOptionHelper {
+  static CheckIfIsFilterOption = <Model extends ModelBaseStructure>(
+    filter: any,
+  ): filter is RepositoryFindFieltersOptions<Model, any> => !isNil(filter?.operator)
+
+  static GetValueFromFilter = <Model extends ModelBaseStructure<Model>>(
+    filter: RepositoryFindFieltersOptions<Model, any>,
+    fieldOption: ColumnOptions<any, any>,
+  ): any => {
+    if (!FilterOptionHelper.CheckIfIsFilterOption(filter)) return filter
+
+    if (filter.operator === Where.ISNULL) return true
+
+    if (filter.operator === Where.ISNOTNULL) return false
+
+    const converter = fieldOption.to
+      ? fieldOption.to
+      : (value: any) =>
+        filter.operator === Where.LIKE && !Array.isArray(filter.value) && value.indexOf('%') < 0
+          ? `%${value}%`
+          : value
+    const converterResult =
+      Array.isArray(filter.value) && !fieldOption.fields && [Where.IN, Where.NOTIN].includes(filter.operator)
+        ? filter.value.map((fieldValue) => converter(fieldValue))
+        : converter(filter.value as any)
+    const newValue =
+      filter.ignoreCase && !filter.ignoreAccent && !Array.isArray(filter.value) && converterResult.indexOf('%') < 0
+        ? `%${converterResult}%`
+        : converterResult
+
+    return filter.ignoreAccent && !Array.isArray(filter.value)
+      ? FilterOptionHelper.buildInsensitiveSentence(newValue)
+      : newValue
+  }
+
+  private static buildInsensitiveSentence = (value: string) => {
+    const valueWithoutAccents = FilterOptionHelper.removeAccents(value)
+    let result = ''
+
+    for (const char of valueWithoutAccents) {
+      const allCharOptions: string[] = []
+
+      if (['a', 'e', 'i', 'o', 'u', 'c', 'A', 'E', 'I', 'O', 'U', 'C'].includes(char)) {
+        const charOptions: Record<string, string[]> = {
+          a: ['á', 'â', 'ã', 'à', 'a'],
+          e: ['é', 'ê', 'ẽ', 'è', 'e'],
+          i: ['í', 'î', 'ĩ', 'ì', 'i'],
+          o: ['ó', 'ô', 'õ', 'ò', 'o'],
+          u: ['ú', 'û', 'ũ', 'ù', 'u'],
+          c: ['ç', 'c'],
+          A: ['Á', 'Â', 'Ã', 'À', 'A'],
+          E: ['É', 'Ê', 'Ẽ', 'È', 'E'],
+          I: ['Í', 'Î', 'Ĩ', 'Ì', 'I'],
+          O: ['Ó', 'Ô', 'Õ', 'Ò', 'O'],
+          U: ['Ú', 'Û', 'Ũ', 'Ù', 'U'],
+          C: ['Ç', 'C'],
+        }
+
+        allCharOptions.push(...charOptions[char])
+
+        result += `[${allCharOptions.join('')}]`
+      } else {
+        result += char
+      }
+    }
+
+    return result
+  }
+  private static removeAccents = (text: string) => {
+    return text.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-binding.helper.ts

@@ -0,0 +1,93 @@
+import {
+  FindRepositoryParams,
+  ModelBaseStructure,
+  NonFunctionAndIdentifierPropertyNames,
+  RepositoryOrderBy,
+} from '../../../../../domain'
+import { HasuraGraphQLFields } from '../../../types'
+
+export class HasuraFindBindingHelper {
+  static bindOrderByAttributes<MBase extends ModelBaseStructure<MBase>>(
+    orderBy: RepositoryOrderBy<MBase>,
+    fields: HasuraGraphQLFields<MBase>,
+  ) {
+    return Object.keys(orderBy).reduce(
+      (acc, current) => [
+        ...acc,
+        {
+          [this.getColumnName(current as NonFunctionAndIdentifierPropertyNames<MBase>, fields)]:
+            orderBy[current as NonFunctionAndIdentifierPropertyNames<MBase>] === 'asc'
+              ? 'asc_nulls_last'
+              : 'desc_nulls_last',
+        },
+      ],
+      [],
+    )
+  }
+
+  static bindAggregateAttributes<MBase extends ModelBaseStructure<MBase>>(
+    aggregates: {
+      minimal?: FindRepositoryParams<MBase>['options']['minimal']
+      maximum?: FindRepositoryParams<MBase>['options']['maximum']
+    },
+    fields: HasuraGraphQLFields<MBase>,
+  ) {
+    return [
+      ...(aggregates?.minimal?.length
+        ? [
+            {
+              min: this.bindAttributesToColumns(aggregates.minimal, fields),
+            },
+          ]
+        : []),
+      ...(aggregates?.maximum?.length
+        ? [
+            {
+              max: this.bindAttributesToColumns(aggregates.maximum, fields),
+            },
+          ]
+        : []),
+    ]
+  }
+
+  static bindDistinctAttributes<MBase extends ModelBaseStructure<MBase>>(
+    distinct: FindRepositoryParams<MBase>['options']['distinct'],
+    fields: HasuraGraphQLFields<MBase>,
+  ) {
+    return this.bindAttributesToColumns(distinct, fields)
+  }
+
+  static bindAttributesToColumns<MBase extends ModelBaseStructure<MBase>>(
+    attributes: Array<NonFunctionAndIdentifierPropertyNames<MBase> | any>,
+    fields: HasuraGraphQLFields<MBase>,
+  ) {
+    return attributes.map(
+      (attr) =>
+        this.getColumnName(attr.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>, fields) ||
+        attr,
+    )
+  }
+
+  static getColumnName<MBase extends ModelBaseStructure<MBase>>(
+    attributeName: NonFunctionAndIdentifierPropertyNames<MBase>,
+    fields: HasuraGraphQLFields<MBase>,
+  ): string {
+    const fieldOption = fields.find((field) => {
+      if (typeof field === 'string') return field === attributeName
+
+      if (typeof field === 'object' && field !== null) {
+        return Object.keys(field).includes(attributeName as string)
+      }
+
+      return false
+    })
+
+    if (typeof fieldOption === 'object' && fieldOption !== null) {
+      const columnOption = (fieldOption as any)[attributeName]
+
+      return columnOption?.columnName || attributeName
+    }
+
+    return attributeName as string
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-cache.helper.ts

@@ -0,0 +1,66 @@
+import {
+  BaseModelBuilder,
+  CacheConfig,
+  FindRepositoryParams,
+  ModelBaseStructure,
+  RepositoryCacheOptions,
+} from '../../../../../domain'
+import { deserialize, serialize } from '../../../../../utils'
+import { MD5GeneratorHelper } from '../md5-generator.helper'
+
+export class HasuraFindCacheHelper {
+  static generateCacheKey<MBase extends ModelBaseStructure<MBase>>(
+    model: BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>,
+    params?: FindRepositoryParams<MBase>,
+  ): string {
+    const md5 = MD5GeneratorHelper.generateMD5(params)
+
+    return `${model.name.toLowerCase()}:find:${md5}`
+  }
+
+  static async getCachedResult<MBase extends ModelBaseStructure<MBase>>(params: {
+    cache?: CacheConfig
+    model: BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>
+    findParams?: FindRepositoryParams<MBase>
+    cacheOptions?: RepositoryCacheOptions
+    logger?: any
+  }): Promise<any | null> {
+    const { cache, model, findParams, cacheOptions, logger } = params
+
+    if (!cache?.cacheAdapter || !cacheOptions?.enabled) return null
+
+    const cacheKey = this.generateCacheKey(model, findParams)
+    const cachedData = await cache.cacheAdapter.get<string>(cacheKey)
+
+    if (cachedData) {
+      logger?.log(`Dados recuperados do cache: ${cacheKey}`)
+
+      return deserialize(cachedData)
+    }
+
+    return null
+  }
+
+  static async setCachedResult<MBase extends ModelBaseStructure<MBase>>(params: {
+    cache?: CacheConfig
+    model: BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>
+    findParams?: FindRepositoryParams<MBase>
+    cacheOptions?: RepositoryCacheOptions
+    result: any
+    logger?: any
+  }): Promise<void> {
+    const { cache, model, findParams, cacheOptions, result, logger } = params
+
+    if (!cache?.cacheAdapter || !cacheOptions?.enabled) return
+
+    const cacheKey = this.generateCacheKey(model, findParams)
+
+    await cache.cacheAdapter.set({
+      key: cacheKey,
+      data: serialize(result),
+      expirationInSeconds: cacheOptions?.ttl || cache.ttlDefault,
+    })
+
+    logger?.log(`Dados salvos no cache: ${cacheKey}`)
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/find/hasura-find-operations.helper.ts

@@ -0,0 +1,93 @@
+import {
+  BaseModelBuilder,
+  FindRepositoryParams,
+  ModelBaseStructure,
+  RepositoryCacheOptions,
+  RepositoryFindResult,
+} from '../../../../../domain'
+import { DebugHelper } from '../../../../../utils'
+import { GraphQLParams, HasuraGraphQLFields } from '../../../types'
+
+import { HasuraFindCacheHelper } from './hasura-find-cache.helper'
+import { HasuraFindQueryBuilderHelper } from './hasura-find-query-builder.helper'
+import { HasuraFindResultHelper } from './hasura-find-result.helper'
+
+export interface ExecuteFindParams<MBase extends ModelBaseStructure<MBase>> {
+  params?: FindRepositoryParams<MBase>
+  cacheOptions?: { cache?: RepositoryCacheOptions }
+  model: BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>
+  tableName: string
+  fields: HasuraGraphQLFields<MBase>
+  cache?: any
+  query: (queries: GraphQLParams<MBase>[]) => Promise<any>
+  convertDataFromHasura: (data: any) => MBase
+  lastDistinct: Record<string, any>
+}
+
+export class HasuraFindOperationsHelper {
+  static async executeFindOperation<MBase extends ModelBaseStructure<MBase>>(
+    operationParams: ExecuteFindParams<MBase>,
+  ): Promise<RepositoryFindResult<MBase>> {
+    const { params, cacheOptions, model, tableName, fields, cache, query, convertDataFromHasura, lastDistinct } =
+      operationParams
+
+    const logger = DebugHelper.from(operationParams, 'find')
+    const { filters, options: findOptions } = params || {}
+    const tableFiltersNamed = `${tableName}:${JSON.stringify(filters)}`
+    const enableCount = findOptions?.enableCount ?? true
+
+    // Verifica cache primeiro
+    const cachedResult = await HasuraFindCacheHelper.getCachedResult({
+      cache,
+      model,
+      findParams: params,
+      cacheOptions: cacheOptions?.cache,
+      logger,
+    })
+
+    if (cachedResult) {
+      return HasuraFindResultHelper.processResult({
+        result: cachedResult,
+        tableName,
+        enableCount,
+        findOptions,
+        tableFiltersNamed,
+        fields,
+        convertDataFromHasura,
+        lastDistinct,
+      })
+    }
+
+    // Constrói e executa queries
+    const queries = HasuraFindQueryBuilderHelper.buildCompleteQuery({
+      tableName,
+      fields,
+      params,
+      lastDistinct,
+    })
+
+    const result = await query(queries)
+
+    // Salva no cache se habilitado
+    await HasuraFindCacheHelper.setCachedResult({
+      cache,
+      model,
+      findParams: params,
+      cacheOptions: cacheOptions?.cache,
+      result,
+      logger,
+    })
+
+    // Processa e retorna resultado
+    return HasuraFindResultHelper.processResult({
+      result,
+      tableName,
+      enableCount,
+      findOptions,
+      tableFiltersNamed,
+      fields,
+      convertDataFromHasura,
+      lastDistinct,
+    })
+  }
+}