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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,93 +0,0 @@
-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,
-    })
-  }
-}