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

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

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

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

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

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

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

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

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

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

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

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