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

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

@@ -1,214 +0,0 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions'
-
-import {
-  BaseModel,
-  ModelBaseStructure,
-  NonFunctionAndIdentifierPropertiesWithNoPartial,
-  NonFunctionAndIdentifierPropertyNames,
-  PartialIdentifiersModel,
-} from '../../../../domain'
-import { is, isDate, isEmpty, isNil, isObject, isString, parseDateTime } from '../../../../utils'
-import { ColumnOptions, Fields, GraphQLParams, HasuraGraphQLFields } from '../../types'
-
-import { AttributeOptionHelper } from './attribute-option.helper'
-import { BindFilterQueryHelper } from './bind-filter-query.helper'
-
-export class GraphQLFieldHelper {
-  static CheckIsGraphQLParams = <Model extends ModelBaseStructure<Model>>(
-    params: string | IOperation | GraphQLParams<Model>[],
-  ): params is GraphQLParams<Model>[] =>
-    !isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation
-
-  static ConvertModelFieldsToGraphQLFields = <Model extends ModelBaseStructure<Model>>(
-    fields: HasuraGraphQLFields<Model>,
-  ): Fields => {
-    return fields
-      ?.map((field) => {
-        if (isString(field)) return field.toString()
-
-        if (field === 'affected_rows') return field
-
-        const fieldName = Object.keys(field).shift()
-        const fieldValue = is<ColumnOptions<any, Model>>(field[fieldName as keyof typeof field])
-
-        if (Array.isArray(fieldValue))
-          return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) }
-
-        if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue)) return
-
-        const isNestedField = !!fieldValue.fields
-
-        if (isNestedField) return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue as any)
-
-        return fieldValue.columnName
-      })
-      .filter((field) => !!field)
-  }
-
-  static ConvertFieldValueFrom = <
-    Model extends ModelBaseStructure,
-    RecordDataType extends string | number | DataType | Date,
-    DataType extends Record<string, RecordDataType | RecordDataType[]>,
-  >(
-    data: DataType,
-    fields: HasuraGraphQLFields<Model>,
-  ): NonFunctionAndIdentifierPropertiesWithNoPartial<Model> | PartialIdentifiersModel<Model> =>
-    Object.keys(data).reduce((result, columnName) => {
-      const {
-        attributeName,
-        fields: attributeFields,
-        from,
-      } = AttributeOptionHelper.FindColumnOptionFromList(columnName, fields)
-
-      if (!!attributeFields && Array.isArray(attributeFields)) {
-        if (Array.isArray(data[columnName]))
-          return {
-            ...result,
-            [attributeName]: from
-              ? from(data[columnName], data)
-              : is<RecordDataType[]>(data[columnName]).map((value) =>
-                GraphQLFieldHelper.ConvertFieldValueFrom(is<DataType>(value), attributeFields),
-              ),
-          }
-
-        if (isObject(data[columnName]))
-          return {
-            ...result,
-            [attributeName]: from
-              ? from(data[columnName])
-              : GraphQLFieldHelper.ConvertFieldValueFrom(is<DataType>(data[columnName]), attributeFields),
-          }
-      }
-
-      if (from) return { ...result, [attributeName]: from(data[columnName], data) }
-
-      return {
-        ...result,
-        [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],
-      }
-    }, {})
-
-  static ConvertFieldValueTo = <
-    Model extends ModelBaseStructure<Model>,
-    DataType extends Record<string, string | number | DataType | Date>,
-  >(
-    instance: Model,
-    fields: HasuraGraphQLFields<Model>,
-    update = false,
-  ): DataType => {
-    const data: Partial<Model> = instance.toPlain?.() || instance
-
-    return Object.keys(data).reduce((result, attributeName) => {
-      const {
-        columnName,
-        fields: attributeFields,
-        foreignKeyColumn,
-        to,
-        bindPersistData,
-      } = AttributeOptionHelper.FindByAttribute(attributeName as NonFunctionAndIdentifierPropertyNames<Model>, fields)
-
-      if (bindPersistData)
-        return {
-          ...result,
-          ...bindPersistData(data[attributeName as NonFunctionAndIdentifierPropertyNames<Model>], instance),
-        }
-
-      if (isNil(columnName)) return result
-
-      if (
-        !!foreignKeyColumn &&
-        !isEmpty(foreignKeyColumn) &&
-        !Object.keys(foreignKeyColumn).filter(
-          (key) =>
-            !is<Record<string, string>>(data[attributeName as NonFunctionAndIdentifierPropertyNames<Model>])?.[key],
-        ).length
-      )
-        return Object.keys(foreignKeyColumn).reduce(
-          (object, current) => {
-            const { columnName: foreignColumnName } = AttributeOptionHelper.FindByAttribute(
-              foreignKeyColumn[current as keyof HasuraGraphQLFields<Model>[number]],
-              fields,
-            )
-
-            return {
-              ...object,
-              [foreignColumnName]: data[attributeName as keyof HasuraGraphQLFields<Model>[number]]?.[current],
-            }
-          },
-          { ...result },
-        )
-
-      if (
-        update &&
-        isObject(data[attributeName as keyof HasuraGraphQLFields<Model>[number]]) &&
-        !isNil(attributeFields) &&
-        !isDate(data[attributeName as keyof HasuraGraphQLFields<Model>[number]])
-      )
-        return result
-
-      if (
-        !!columnName &&
-        Array.isArray(attributeFields) &&
-        isObject(data[attributeName as keyof HasuraGraphQLFields<Model>[number]])
-      ) {
-        const converted =
-          !isNil(columnName) && to
-            ? to(instance[attributeName as keyof HasuraGraphQLFields<Model>[number]], instance)
-            : data[attributeName as keyof HasuraGraphQLFields<Model>[number]]
-
-        return {
-          ...result,
-          ...(converted !== undefined
-            ? {
-              [columnName]: {
-                data:
-                    instance[attributeName as NonFunctionAndIdentifierPropertyNames<Model>] instanceof BaseModel
-                      ? GraphQLFieldHelper.ConvertFieldValueTo(
-                        data[attributeName as keyof HasuraGraphQLFields<Model>[number]],
-                          attributeFields as HasuraGraphQLFields<Model>,
-                      )
-                      : converted,
-              },
-            }
-            : {}),
-        }
-      }
-
-      if (to)
-        return {
-          ...result,
-          [columnName]: to(instance[attributeName as keyof HasuraGraphQLFields<Model>[number]], instance),
-        }
-
-      return { ...result, [columnName]: data[attributeName as keyof HasuraGraphQLFields<Model>[number]] }
-    }, {} as DataType)
-  }
-
-  private static ConvertNestedFieldsToGraphQLFields = <
-    T extends ModelBaseStructure<T>,
-    P extends ModelBaseStructure<P>,
-  >(
-    fieldName: string,
-    fieldValue: ColumnOptions<T, P>,
-  ) => {
-    const hasCustomFilters = !!fieldValue.filters
-
-    if (hasCustomFilters)
-      return {
-        operation: fieldValue.columnName || fieldName,
-        fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-        variables: {
-          [`${fieldValue.columnName}_where`]: {
-            name: 'where',
-            type: fieldValue.filters.filterType,
-            value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
-            required: true,
-          },
-        },
-      }
-
-    return {
-      [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-    }
-  }
-}

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

@@ -1,18 +0,0 @@
-import { isNil } from '../../../../utils'
-import { HasuraGraphQLAuthOptions, HasuraGraphQLHeaders } from '../../types'
-
-export class HasuraAuthHelper {
-  static buildHeaders(authOptions: HasuraGraphQLAuthOptions): HasuraGraphQLHeaders {
-    return {
-      'Content-Type': 'application/json',
-      ...(isNil(authOptions?.authToken) ? {} : { Authorization: authOptions?.authToken }),
-      ...(isNil(authOptions?.adminSecret) ? {} : { 'X-Hasura-Admin-Secret': authOptions?.adminSecret }),
-      ...(isNil(authOptions?.authRole)
-        ? {}
-        : {
-            'X-Hasura-Role': authOptions.authRole.role,
-            'X-Hasura-User-Id': authOptions?.authRole?.userId,
-          }),
-    }
-  }
-}

package/src/infra/hasura-graphql/mixins/helpers/hasura-data-converter.helper.ts

@@ -1,51 +0,0 @@
-import { ModelBaseStructure } from '../../../../domain'
-import { isBoolean, isInteger, isNaN, isNumber, isString, isUUID, parseISO } from '../../../../utils'
-import { HasuraGraphQLFields } from '../../types'
-
-import { GraphQLFieldHelper } from './graphql-field.helper'
-
-export class HasuraDataConverterHelper {
-  static getAttributeGraphQLTypeOf<FieldType>(value: FieldType): string {
-    if (isUUID(value as any)) return 'uuid'
-
-    if (isString(value)) return 'String'
-
-    if (isBoolean(value)) return 'Boolean'
-
-    if (value instanceof Date) return 'timestamptz'
-
-    if (isInteger(value)) return 'Int'
-
-    if (isNumber(value)) return 'numeric'
-
-    throw new Error('Type not implemented yet')
-  }
-
-  static checkIfIsDateTimeAndParse(value: string): Date | string {
-    if (!/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.test(value)) return value
-
-    const date = parseISO(value)
-
-    if (isNaN(date.getTime())) return value
-
-    return date
-  }
-
-  static convertDataFromHasura<MBase extends ModelBaseStructure<MBase>>(
-    data: Record<string, string | number>,
-    fields: HasuraGraphQLFields<MBase>,
-    model: any,
-  ): MBase {
-    const plain = GraphQLFieldHelper.ConvertFieldValueFrom(data, fields)
-
-    return model.toInstance(plain)
-  }
-
-  static convertDataToHasura<MBase extends ModelBaseStructure<MBase>>(
-    instance: MBase,
-    fields: HasuraGraphQLFields<MBase>,
-    update = false,
-  ): Record<string, string | number> {
-    return GraphQLFieldHelper.ConvertFieldValueTo(instance, fields, update)
-  }
-}

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

@@ -1,66 +0,0 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions'
-
-import { ModelBaseStructure } from '../../../../domain'
-import { DebugHelper } from '../../../../utils'
-import { GraphQLParams, HasuraGraphQLAuthOptions, HasuraGraphQLFields, VariableOptions } from '../../types'
-
-import { HasuraAuthHelper } from './hasura-auth.helper'
-import { HasuraQueryBuilderHelper, QueryBuilderOptions } from './hasura-query-builder.helper'
-import { HasuraRequestHelper } from './hasura-request.helper'
-
-export interface GraphQLOperationParams<MBase extends ModelBaseStructure<MBase>> {
-  endpoint: string
-  authOptions: HasuraGraphQLAuthOptions
-  fields: HasuraGraphQLFields<MBase>
-  interceptors?: any
-  logger: DebugHelper
-}
-
-export class HasuraGraphQLOperationsHelper {
-  static async executeMutation<MBase extends ModelBaseStructure<MBase>, ReturnFields = any>(params: {
-    operation: string | IOperation
-    fields?: string[] | HasuraGraphQLFields<MBase>
-    variables?: VariableOptions
-    operationParams: GraphQLOperationParams<MBase>
-  }): Promise<ReturnFields> {
-    const { operation, fields, variables, operationParams } = params
-    const resultQuery = HasuraQueryBuilderHelper.buildMutation(operation, fields, variables)
-
-    return this.executeFetch({ query: resultQuery, operationParams })
-  }
-
-  static async executeQuery<MBase extends ModelBaseStructure<MBase>, ReturnFields = any>(params: {
-    operation: string | IOperation | GraphQLParams<MBase>[]
-    fields?: string[] | HasuraGraphQLFields<MBase>
-    variables?: VariableOptions
-    operationParams: GraphQLOperationParams<MBase>
-    buildHasuraQueryFields: (params: {
-      operation: string | IOperation | GraphQLParams<MBase>[]
-      fields?: string[] | HasuraGraphQLFields<MBase>
-      variables?: VariableOptions
-    }) => QueryBuilderOptions | QueryBuilderOptions[]
-  }): Promise<ReturnFields> {
-    const { operation, fields, variables, operationParams, buildHasuraQueryFields } = params
-
-    const builded = buildHasuraQueryFields({ operation, fields, variables })
-    const intercepted = (await operationParams.interceptors?.request?.(builded)) || builded
-    const resultQuery = HasuraQueryBuilderHelper.buildQuery(intercepted)
-    const result = await this.executeFetch({ query: resultQuery, operationParams })
-
-    return (await operationParams.interceptors?.response?.(result, intercepted)) || result
-  }
-
-  private static async executeFetch<ReturnFields = any>(params: {
-    query: { variables: any; query: string }
-    operationParams: GraphQLOperationParams<any>
-  }): Promise<ReturnFields> {
-    const { query, operationParams } = params
-
-    return HasuraRequestHelper.fetch({
-      ...query,
-      endpoint: operationParams.endpoint,
-      headers: HasuraAuthHelper.buildHeaders(operationParams.authOptions),
-      logger: operationParams.logger,
-    })
-  }
-}

package/src/infra/hasura-graphql/mixins/helpers/hasura-query-builder.helper.ts

@@ -1,53 +0,0 @@
-import { mutation, query } from 'gql-query-builder'
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions'
-
-import { ModelBaseStructure } from '../../../../domain'
-import { Fields, GraphQLParams, HasuraGraphQLFields, VariableOptions } from '../../types'
-
-import { GraphQLFieldHelper } from './graphql-field.helper'
-
-export type QueryBuilderOptions = {
-  operation: string | IOperation
-  fields: Fields
-  variables?: VariableOptions
-}
-
-export class HasuraQueryBuilderHelper {
-  static buildMutation<MBase extends ModelBaseStructure<MBase>>(
-    operation: string | IOperation,
-    fields?: string[] | HasuraGraphQLFields<MBase>,
-    variables?: VariableOptions,
-  ): { variables: any; query: string } {
-    return mutation({
-      operation,
-      variables,
-      fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields as HasuraGraphQLFields<MBase>),
-    })
-  }
-
-  static buildQuery<MBase extends ModelBaseStructure<MBase>>(
-    params: QueryBuilderOptions | QueryBuilderOptions[],
-  ): { variables: any; query: string } {
-    return query(params)
-  }
-
-  static buildHasuraQueryFields<MBase extends ModelBaseStructure<MBase>>(params: {
-    operation: string | IOperation | GraphQLParams<MBase>[]
-    fields?: string[] | HasuraGraphQLFields<MBase>
-    variables?: VariableOptions
-  }): QueryBuilderOptions | QueryBuilderOptions[] {
-    const { operation, fields, variables } = params
-
-    return GraphQLFieldHelper.CheckIsGraphQLParams(operation)
-      ? operation.map((option) => ({
-          operation: option.operation,
-          variables: option.variables,
-          fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(option.fields),
-        }))
-      : {
-          operation,
-          variables,
-          fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fields as HasuraGraphQLFields<MBase>),
-        }
-  }
-}

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

@@ -1,34 +0,0 @@
-import axios from 'axios'
-
-import { DebugHelper, isNil } from '../../../../utils'
-import { HasuraGraphQLHeaders } from '../../types'
-
-export class HasuraRequestHelper {
-  static async fetch<ReturnFields = any>(params: {
-    variables: any
-    query: string
-    endpoint: string
-    headers: HasuraGraphQLHeaders
-    logger: DebugHelper
-  }): Promise<ReturnFields> {
-    const { variables, query, endpoint, headers, logger } = params
-
-    const request = {
-      url: endpoint,
-      method: 'POST' as const,
-      data: { variables, query },
-      headers,
-    }
-
-    const response = await axios(request)
-
-    if (!isNil(response.data.errors)) {
-      logger.error({ req: request, res: response.data.errors })
-      throw new Error(JSON.stringify(response.data.errors))
-    }
-
-    logger.log({ req: request, res: response.data })
-
-    return response.data.data
-  }
-}

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

@@ -1,21 +0,0 @@
-// Helpers gerais (usados em múltiplas operações)
-export * from './attribute-option.helper'
-export * from './bind-filter-query.helper'
-export * from './cache-key-generator.helper'
-export * from './filter-option.helper'
-export { GraphQLFieldHelper } from './graphql-field.helper'
-export * from './md5-generator.helper'
-
-// Helpers do with-hasura-graphql.mixin.ts (core)
-export { HasuraAuthHelper } from './hasura-auth.helper'
-export { HasuraDataConverterHelper } from './hasura-data-converter.helper'
-export { GraphQLOperationParams, HasuraGraphQLOperationsHelper } from './hasura-graphql-operations.helper'
-export { HasuraQueryBuilderHelper, QueryBuilderOptions } from './hasura-query-builder.helper'
-export { HasuraRequestHelper } from './hasura-request.helper'
-
-// Helpers por operação
-export * from './create'
-export * from './delete'
-export * from './find'
-export * from './get'
-export * from './update'

package/src/infra/hasura-graphql/mixins/helpers/md5-generator.helper.ts

@@ -1,41 +0,0 @@
-import { Md5 } from 'ts-md5'
-
-export class MD5GeneratorHelper {
-  static generateMD5(data: any): string {
-    if (data === null || data === undefined) return Md5.hashStr('null')
-
-    const normalizedData = this.normalizeData(data)
-    const jsonString = JSON.stringify(normalizedData)
-
-    return Md5.hashStr(jsonString)
-  }
-
-  private static normalizeData(data: any, depth = 0, maxDepth = 100): any {
-    if (depth > maxDepth) return '[MAX_DEPTH_REACHED]'
-
-    if (data === null || data === undefined) return null
-
-    if (typeof data !== 'object') return data
-
-    if (Array.isArray(data))
-      return data
-        .map((item) => this.normalizeData(item, depth + 1, maxDepth))
-        .sort((a, b) => {
-          const strA = typeof a === 'object' && a !== null ? JSON.stringify(a) : String(a)
-          const strB = typeof b === 'object' && b !== null ? JSON.stringify(b) : String(b)
-
-          return strA.localeCompare(strB)
-        })
-
-    const sortedObj: Record<string, any> = {}
-    const keys = Object.keys(data).sort()
-
-    keys.forEach((key) => {
-      const value = data[key]
-
-      sortedObj[key] = this.normalizeData(value, depth + 1, maxDepth)
-    })
-
-    return sortedObj
-  }
-}

package/src/infra/hasura-graphql/mixins/helpers/update/hasura-update-data.helper.ts

@@ -1,59 +0,0 @@
-import {
-  BaseModel,
-  BaseModelBuilder,
-  ModelBaseStructure,
-  RepositoryUpdateParams,
-  UpdateOptionActions,
-  UpdateOptions,
-} from '../../../../../domain'
-import { is, isNil } from '../../../../../utils'
-
-export class HasuraUpdateDataHelper {
-  static getValueByAction<MBase extends ModelBaseStructure<MBase>>(options: UpdateOptions<MBase>): unknown {
-    if (options instanceof BaseModel) return options.toPlain()
-
-    if (isNil(options?.action)) return options
-
-    if ([UpdateOptionActions.REMOVE_FIELD.toString(), UpdateOptionActions.NULL.toString()].includes(options.action))
-      return null
-
-    return options.value
-  }
-
-  static paramsToPlain<MBase extends ModelBaseStructure<MBase>>(
-    params: RepositoryUpdateParams<MBase>,
-    model: BaseModelBuilder<MBase>,
-  ): Partial<MBase> {
-    if (model.isModel(params)) return params.toPlain()
-
-    return Object.keys(params).reduce(
-      (data, currentKey) => ({
-        ...data,
-        ...(params[currentKey as keyof RepositoryUpdateParams<MBase>] !== undefined && {
-          [currentKey]: this.getValueByAction(
-            is<UpdateOptions<MBase>>(params[currentKey as keyof RepositoryUpdateParams<MBase>]),
-          ),
-        }),
-      }),
-      {},
-    )
-  }
-
-  static getIdentifiersFromData<MBase extends ModelBaseStructure<MBase>>(
-    data: Partial<MBase>,
-    model: any,
-  ): Record<string, any> {
-    const instance = model.toInstance(data)
-    const identifiers: Record<string, any> = {}
-
-    model.identifiersFields.forEach((identifier: any) => {
-      const field = identifier as keyof MBase
-
-      if (!isNil(instance[field])) {
-        identifiers[String(field)] = instance[field]
-      }
-    })
-
-    return identifiers
-  }
-}

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

@@ -1,79 +0,0 @@
-import { ModelBaseStructure, RepositoryUpdateParams } from '../../../../../domain'
-import { DebugHelper } from '../../../../../utils'
-import { HasuraGraphQLFields } from '../../../types'
-import { CacheKeyGeneratorHelper } from '../cache-key-generator.helper'
-
-import { HasuraUpdateDataHelper } from './hasura-update-data.helper'
-import { HasuraUpdateVariablesHelper } from './hasura-update-variables.helper'
-
-export interface UpdateOperationsParams<MBase extends ModelBaseStructure<MBase>> {
-  data: RepositoryUpdateParams<MBase>
-  updateGraphQLOperation: string
-  updateGraphQLObjectType: string
-  updateGraphQLPKType: string
-  model: any
-  fields: any
-  cache?: any
-  logger?: any
-  mutation: (operation: string, fields: HasuraGraphQLFields<MBase>, variables: any) => Promise<any>
-  convertDataToHasura: (data: any, isUpdate?: boolean) => any
-}
-
-export class HasuraUpdateOperationsHelper {
-  static async executeUpdateOperation<MBase extends ModelBaseStructure<MBase>>(
-    params: UpdateOperationsParams<MBase>,
-  ): Promise<MBase> {
-    const {
-      data,
-      updateGraphQLOperation,
-      updateGraphQLObjectType,
-      updateGraphQLPKType,
-      model,
-      fields,
-      cache,
-      mutation,
-      convertDataToHasura,
-    } = params
-
-    const logger = DebugHelper.from(params, 'update')
-    const plainData = HasuraUpdateDataHelper.paramsToPlain(data, model)
-
-    // Gerencia cache se disponível
-    await this.handleCacheRemoval({ plainData, model, cache, logger })
-
-    // Executa mutation
-    const identifierFields = HasuraUpdateVariablesHelper.getIdentifierFields<MBase>(model, fields)
-    const mutationVariables = HasuraUpdateVariablesHelper.buildMutationVariables({
-      plainData,
-      updateGraphQLObjectType,
-      updateGraphQLPKType,
-      convertDataToHasura,
-      getUpdateModelKeys: (data) => HasuraUpdateVariablesHelper.getUpdateModelKeys(data, model, fields),
-      model,
-    })
-
-    await mutation(updateGraphQLOperation, identifierFields, mutationVariables)
-
-    return model.toInstance(plainData)
-  }
-
-  private static async handleCacheRemoval<MBase extends ModelBaseStructure<MBase>>(params: {
-    plainData: Partial<MBase>
-    model: any
-    cache?: any
-    logger?: any
-  }): Promise<void> {
-    const { plainData, model, cache, logger } = params
-
-    if (!cache?.cacheAdapter) return
-
-    const identifiers = HasuraUpdateDataHelper.getIdentifiersFromData(plainData, model)
-
-    if (Object.keys(identifiers).length > 0) {
-      const cacheKey = CacheKeyGeneratorHelper.generateCacheKeyFromIdentifiers(model, identifiers)
-
-      await cache.cacheAdapter.remove(cacheKey)
-      logger?.log(`Cache removido: ${cacheKey}`)
-    }
-  }
-}