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

package/src/infra/hasura-graphql/mixins/factories/create-hasura-class.factory.ts

@@ -1,56 +0,0 @@
-import { CreateRepository, CreateRepositoryParams, ModelBaseStructure } from '../../../../domain'
-import { MixinCtor } from '../../../../utils'
-import { GraphQLRepository } from '../../types'
-import { HasuraCreateOperationsHelper } from '../helpers'
-
-export type CreateConstructorParams = {
-  insertGraphQLOperation?: string
-  insertAllGraphQLOperation?: string
-  insertGraphQLObjectType?: string
-}
-
-export function createCreateHasuraGraphQLClass<
-  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
-  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
->(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) {
-  return class CreateHasuraGraphQLMixin extends MixinBase implements CreateRepository<MBase> {
-    insertGraphQLOperation: string
-    insertGraphQLObjectType: string
-
-    constructor(...params: any[]) {
-      const options: CreateConstructorParams = params?.[0]
-
-      super(...params)
-
-      this.insertGraphQLOperation = HasuraCreateOperationsHelper.buildInsertOperationName(
-        this.tableName,
-        options?.insertGraphQLOperation,
-      )
-      this.insertGraphQLObjectType = HasuraCreateOperationsHelper.buildInsertObjectType(
-        this.tableName,
-        options?.insertGraphQLObjectType,
-      )
-    }
-
-    async create(data: CreateRepositoryParams<MBase>): Promise<MBase> {
-      return HasuraCreateOperationsHelper.executeCreate(data, {
-        repository: this,
-        insertGraphQLOperation: this.insertGraphQLOperation,
-        insertGraphQLObjectType: this.insertGraphQLObjectType,
-        fields: this.fields,
-        model: this.model,
-      })
-    }
-
-    async save(data: MBase): Promise<Partial<MBase>> {
-      return HasuraCreateOperationsHelper.executeSave({
-        data,
-        repository: this,
-        insertGraphQLOperation: this.insertGraphQLOperation,
-        insertGraphQLObjectType: this.insertGraphQLObjectType,
-        fields: this.fields,
-        model: this.model,
-      })
-    }
-  }
-}

package/src/infra/hasura-graphql/mixins/factories/delete-hasura-class.factory.ts

@@ -1,39 +0,0 @@
-import { DeleteRepository, DeleteRepositoryParams, ModelBaseStructure } from '../../../../domain'
-import { MixinCtor } from '../../../../utils'
-import { GraphQLRepository } from '../../types'
-import { HasuraDeleteOperationsHelper } from '../helpers'
-
-export type DeleteConstructorParams = {
-  deleteGraphQLOperation?: string
-}
-
-export function createDeleteHasuraGraphQLClass<
-  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
-  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
->(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) {
-  return class DeleteHasuraGraphQLMixin extends MixinBase implements DeleteRepository<MBase> {
-    deleteGraphQLOperation: string
-
-    constructor(...params: any[]) {
-      const options: DeleteConstructorParams = params?.[0]
-
-      super(...params)
-
-      this.deleteGraphQLOperation = HasuraDeleteOperationsHelper.buildDeleteOperationName(
-        this.tableName,
-        options?.deleteGraphQLOperation,
-      )
-    }
-
-    async delete(identifiers: DeleteRepositoryParams<MBase>): Promise<void> {
-      await HasuraDeleteOperationsHelper.executeDelete({
-        identifiers,
-        repository: this,
-        deleteGraphQLOperation: this.deleteGraphQLOperation,
-        fields: this.fields,
-        model: this.model,
-        cache: this.cache,
-      })
-    }
-  }
-}

package/src/infra/hasura-graphql/mixins/factories/find-hasura-class.factory.ts

@@ -1,45 +0,0 @@
-import {
-  BaseModelBuilder,
-  FindRepository,
-  FindRepositoryParams,
-  ModelBaseStructure,
-  RepositoryCacheOptions,
-  RepositoryFindResult,
-} from '../../../../domain'
-import { MixinCtor } from '../../../../utils'
-import { GraphQLRepository } from '../../types'
-import { ExecuteFindParams, HasuraFindBindingHelper, HasuraFindOperationsHelper } from '../helpers'
-
-export function createFindHasuraGraphQLClass<
-  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
-  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
->(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) {
-  return class FindHasuraGraphQLMixin extends MixinBase implements FindRepository<MBase> {
-    lastDistinct: Record<string, any> = {}
-
-    bindOrderByAttributes = HasuraFindBindingHelper.bindOrderByAttributes
-    bindAggregateAttributes = HasuraFindBindingHelper.bindAggregateAttributes
-    bindDistinctAttributes = HasuraFindBindingHelper.bindDistinctAttributes
-    bindAttributesToColumns = HasuraFindBindingHelper.bindAttributesToColumns
-    getColumnName = HasuraFindBindingHelper.getColumnName
-
-    async find(
-      params?: FindRepositoryParams<MBase>,
-      options?: { cache?: RepositoryCacheOptions },
-    ): Promise<RepositoryFindResult<MBase>> {
-      const operationParams: ExecuteFindParams<MBase> = {
-        params,
-        cacheOptions: options,
-        model: this.model as BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>,
-        tableName: this.tableName,
-        fields: this.fields,
-        cache: this.cache,
-        query: this.query.bind(this),
-        convertDataFromHasura: this.convertDataFromHasura.bind(this),
-        lastDistinct: this.lastDistinct,
-      }
-
-      return HasuraFindOperationsHelper.executeFindOperation(operationParams)
-    }
-  }
-}

package/src/infra/hasura-graphql/mixins/factories/get-hasura-class.factory.ts

@@ -1,44 +0,0 @@
-import { GetRepository, GetRepositoryParams, ModelBaseStructure, RepositoryCacheOptions } from '../../../../domain'
-import { MixinCtor } from '../../../../utils'
-import { GraphQLRepository } from '../../types'
-import { HasuraGetCacheHelper, HasuraGetOperationsHelper } from '../helpers'
-
-export type GetConstructorParams = {
-  getGraphQLOperation?: string
-}
-
-export function createGetHasuraGraphQLClass<
-  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
-  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
->(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) {
-  return class GetHasuraGraphQLMixin extends MixinBase implements GetRepository<MBase> {
-    getGraphQLOperation: string
-
-    constructor(...params: any[]) {
-      const options: GetConstructorParams = params?.[0]
-
-      super(...params)
-
-      this.getGraphQLOperation = HasuraGetOperationsHelper.buildGetOperationName(
-        this.tableName,
-        options?.getGraphQLOperation,
-      )
-    }
-
-    generateCacheKey(identifiers: GetRepositoryParams<MBase>): string {
-      return HasuraGetCacheHelper.generateCacheKey(this.model, identifiers)
-    }
-
-    async get(identifiers: GetRepositoryParams<MBase>, options?: { cache?: RepositoryCacheOptions }): Promise<MBase> {
-      return HasuraGetOperationsHelper.executeGet({
-        identifiers,
-        options,
-        repository: this,
-        getGraphQLOperation: this.getGraphQLOperation,
-        fields: this.fields,
-        model: this.model,
-        cache: this.cache,
-      })
-    }
-  }
-}

package/src/infra/hasura-graphql/mixins/factories/hasura-graphql-class.factory.ts

@@ -1,124 +0,0 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions'
-
-import { BaseModelBuilder, CacheConfig, ModelBaseStructure } from '../../../../domain'
-import { DebugHelper, MixinCtor } from '../../../../utils'
-import {
-  GraphQLParams,
-  GraphQLRepository,
-  HasuraGraphQLAuthOptions,
-  HasuraGraphQLFields,
-  VariableOptions,
-} from '../../types'
-import {
-  GraphQLOperationParams,
-  HasuraAuthHelper,
-  HasuraDataConverterHelper,
-  HasuraGraphQLOperationsHelper,
-  HasuraQueryBuilderHelper,
-  QueryBuilderOptions,
-} from '../helpers'
-
-export interface HasuraGraphQLInterceptors<P = QueryBuilderOptions | QueryBuilderOptions[]> {
-  request?: <R>(request: P) => Promise<P & R>
-  response?: <R>(response: R, request: P) => Promise<R>
-}
-
-export interface HasuraConstructorParams<Model extends ModelBaseStructure<Model, Model['identifiersFields'][number]>> {
-  tableName: string
-  model: BaseModelBuilder<Model>
-  fields: HasuraGraphQLFields<Model>
-  endpoint: string
-  interceptors?: HasuraGraphQLInterceptors
-  authOptions: HasuraGraphQLAuthOptions
-  cache?: CacheConfig
-}
-
-export function createHasuraGraphQLClass<
-  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
-  T extends MixinCtor = MixinCtor,
->(MixinBase: T) {
-  return class HasuraGraphQLMixin extends MixinBase implements GraphQLRepository<MBase> {
-    tableName: string
-    endpoint: string
-    authOptions: HasuraGraphQLAuthOptions
-    interceptors: HasuraGraphQLInterceptors
-    model: BaseModelBuilder<MBase>
-    fields: HasuraGraphQLFields<MBase>
-    logger: DebugHelper
-    cache?: CacheConfig
-
-    getAttributeGraphQLTypeOf = HasuraDataConverterHelper.getAttributeGraphQLTypeOf
-    checkIfIsDateTimeAndParse = HasuraDataConverterHelper.checkIfIsDateTimeAndParse
-    buildHasuraQueryFields = HasuraQueryBuilderHelper.buildHasuraQueryFields
-
-    constructor(...params: any[]) {
-      const options: HasuraConstructorParams<MBase> = params[0]
-
-      super(...params)
-
-      this.tableName = options.tableName
-      this.endpoint = options.endpoint
-      this.authOptions = options.authOptions
-      this.model = options.model
-      this.fields = options.fields || (this.model.identifiersFields as HasuraGraphQLFields<MBase>)
-      this.logger = DebugHelper.from(this)
-      this.cache = options.cache
-    }
-
-    get headers() {
-      return HasuraAuthHelper.buildHeaders(this.authOptions)
-    }
-
-    async mutation<ReturnFields = any>(
-      operation: string | IOperation,
-      fields?: string[] | HasuraGraphQLFields<MBase>,
-      variables?: VariableOptions,
-    ): Promise<ReturnFields> {
-      return HasuraGraphQLOperationsHelper.executeMutation({
-        operation,
-        fields,
-        variables,
-        operationParams: this.getOperationParams(),
-      })
-    }
-
-    async query<ReturnFields = any>(
-      operation: string | IOperation | GraphQLParams<MBase>[],
-      fields?: string[] | HasuraGraphQLFields<MBase>,
-      variables?: VariableOptions,
-    ): Promise<ReturnFields> {
-      return HasuraGraphQLOperationsHelper.executeQuery({
-        operation,
-        fields,
-        variables,
-        operationParams: this.getOperationParams(),
-        buildHasuraQueryFields: this.buildHasuraQueryFields.bind(this),
-      })
-    }
-
-    convertDataFromHasura(
-      data: Record<string, string | number>,
-      fields?: string[] | HasuraGraphQLFields<MBase>,
-    ): MBase {
-      return HasuraDataConverterHelper.convertDataFromHasura(
-        data,
-        (fields as HasuraGraphQLFields<MBase>) || this.fields,
-        this.model,
-      )
-    }
-
-    convertDataToHasura(instance: MBase, update = false): Record<string, string | number> {
-      return HasuraDataConverterHelper.convertDataToHasura(instance, this.fields, update)
-    }
-
-    getOperationParams(): GraphQLOperationParams<MBase> {
-      return {
-        endpoint: this.endpoint,
-        authOptions: this.authOptions,
-        fields: this.fields,
-        interceptors: this.interceptors,
-        logger: this.logger,
-      }
-    }
-  }
-}

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

@@ -1,6 +0,0 @@
-export * from './create-hasura-class.factory'
-export * from './delete-hasura-class.factory'
-export * from './find-hasura-class.factory'
-export * from './get-hasura-class.factory'
-export * from './hasura-graphql-class.factory'
-export * from './update-hasura-class.factory'

package/src/infra/hasura-graphql/mixins/factories/update-hasura-class.factory.ts

@@ -1,75 +0,0 @@
-import {
-  ModelBaseStructure,
-  NonFunctionAndIdentifierProperties,
-  RepositoryUpdateParams,
-  UpdateRepository,
-} from '../../../../domain'
-import { MixinCtor } from '../../../../utils'
-import { GraphQLRepository } from '../../types'
-import {
-  HasuraUpdateDataHelper,
-  HasuraUpdateOperationsHelper,
-  HasuraUpdateVariablesHelper,
-  UpdateOperationsParams,
-} from '../helpers'
-
-export interface UpdateConstructorParams {
-  updateGraphQLOperation?: string
-  updateGraphQLObjectType?: string
-  updateGraphQLPKType?: string
-}
-
-export interface UpdateHasuraGraphQLRepositoryType<
-  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
-> extends UpdateRepository<MBase> {
-  paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>
-}
-
-export function createUpdateHasuraGraphQLClass<
-  MBase extends ModelBaseStructure<MBase>,
-  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
->(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) {
-  return class UpdateHasuraGraphQLMixin extends MixinBase implements UpdateRepository<MBase> {
-    updateGraphQLOperation: string
-    updateGraphQLObjectType: string
-    updateGraphQLPKType: string
-
-    constructor(...params: any[]) {
-      const options: UpdateConstructorParams = params?.[0]
-
-      super(...params)
-
-      this.updateGraphQLOperation = options?.updateGraphQLOperation || `update_${this.tableName}_by_pk`
-      this.updateGraphQLObjectType = options?.updateGraphQLObjectType || `${this.tableName}_set_input`
-      this.updateGraphQLPKType = options?.updateGraphQLPKType || `${this.tableName}_pk_columns_input`
-    }
-
-    getIdentifiersFromData(data: Partial<MBase>): Record<string, any> {
-      return HasuraUpdateDataHelper.getIdentifiersFromData(data, this.model)
-    }
-
-    async update(data: RepositoryUpdateParams<MBase>): Promise<MBase> {
-      const operationParams: UpdateOperationsParams<MBase> = {
-        data,
-        updateGraphQLOperation: this.updateGraphQLOperation,
-        updateGraphQLObjectType: this.updateGraphQLObjectType,
-        updateGraphQLPKType: this.updateGraphQLPKType,
-        model: this.model,
-        fields: this.fields,
-        cache: this.cache,
-        mutation: this.mutation.bind(this),
-        convertDataToHasura: this.convertDataToHasura.bind(this),
-      }
-
-      return HasuraUpdateOperationsHelper.executeUpdateOperation(operationParams)
-    }
-
-    paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase> {
-      return HasuraUpdateDataHelper.paramsToPlain(params, this.model)
-    }
-
-    getUpdateModelKeys(data: Partial<MBase>): NonFunctionAndIdentifierProperties<MBase> {
-      return HasuraUpdateVariablesHelper.getUpdateModelKeys(data, this.model, this.fields)
-    }
-  }
-}

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

@@ -1,72 +0,0 @@
-import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../../domain'
-import { is, isNil, isObject } from '../../../../utils'
-import { ColumnOptions, HasuraGraphQLFields } from '../../types'
-
-type FindByAttributeResult<
-  MBase extends ModelBaseStructure<MBase>,
-  Attribute extends NonFunctionAndIdentifierPropertyNames<MBase>,
-> = ColumnOptions<MBase[Attribute], MBase> & { attributeName: Attribute }
-
-export class AttributeOptionHelper {
-  static FindByAttribute = <
-    MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
-    Attribute extends NonFunctionAndIdentifierPropertyNames<MBase> = NonFunctionAndIdentifierPropertyNames<MBase>,
-  >(
-    attributeName: Attribute,
-    fields: HasuraGraphQLFields<MBase>,
-  ): FindByAttributeResult<MBase, Attribute> => {
-    if (fields.includes(attributeName as any))
-      return { columnName: attributeName.toString(), attributeName, to: (value) => value, from: (value) => value }
-
-    const field = fields.find(
-      (columnOption) => isObject(columnOption) && Object.keys(columnOption).includes(attributeName.toString()),
-    )
-    const fieldOption = is<Record<Attribute, ColumnOptions<MBase[Attribute], MBase>>>(field)?.[attributeName]
-
-    if (isNil(fieldOption)) return { columnName: attributeName.toString(), attributeName }
-
-    if (Array.isArray(fieldOption)) return { columnName: attributeName.toString(), attributeName, fields: fieldOption }
-
-    return { attributeName, columnName: attributeName.toString(), ...fieldOption }
-  }
-
-  static CheckIsColumnOption = <Model extends ModelBaseStructure<Model>, ParentModel extends ModelBaseStructure>(
-    fieldValue: ColumnOptions<Model, ParentModel> | any,
-  ): fieldValue is ColumnOptions<Model, ParentModel> => !!fieldValue?.columnName
-
-  static FindColumnOptionFromList = <Model extends ModelBaseStructure, ParentModel extends ModelBaseStructure>(
-    columnName: string,
-    fields: HasuraGraphQLFields<ParentModel>,
-  ): ColumnOptions<Model, ParentModel> & { attributeName: NonFunctionAndIdentifierPropertyNames<ParentModel> } => {
-    if (fields.includes(columnName as HasuraGraphQLFields<ParentModel>[number]))
-      return { columnName, attributeName: columnName as NonFunctionAndIdentifierPropertyNames<ParentModel> }
-
-    const field = is<Record<NonFunctionAndIdentifierPropertyNames<ParentModel>, ColumnOptions<Model, ParentModel>>>(
-      fields.find((field) => {
-        if (!isObject(field)) return false
-
-        const columnOption = Object.values(field).find((option) =>
-          AttributeOptionHelper.CheckIsColumnOption(option) && option.columnName === columnName ? option : {},
-        )
-
-        return AttributeOptionHelper.CheckIsColumnOption(columnOption) && columnOption?.columnName === columnName
-      }) || {},
-    )
-    const attributeName = Object.keys(field).find(
-      (fieldOptionFromList) =>
-        AttributeOptionHelper.CheckIsColumnOption(
-          field[fieldOptionFromList as NonFunctionAndIdentifierPropertyNames<ParentModel>],
-        ) || Array.isArray(field[fieldOptionFromList as NonFunctionAndIdentifierPropertyNames<ParentModel>]),
-    ) as NonFunctionAndIdentifierPropertyNames<ParentModel>
-    const fieldOption = field?.[attributeName]
-
-    if (Array.isArray(fieldOption))
-      return { attributeName: attributeName as NonFunctionAndIdentifierPropertyNames<ParentModel>, fields: fieldOption }
-
-    return {
-      attributeName: attributeName || (columnName as NonFunctionAndIdentifierPropertyNames<ParentModel>),
-      columnName,
-      ...fieldOption,
-    }
-  }
-}

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

@@ -1,177 +0,0 @@
-import {
-  ModelBaseStructure,
-  NonFunctionAndIdentifierPropertyNames,
-  NonFunctionPropertyNames,
-  RepositoryFindFielters,
-  RepositoryFindFieltersOptions,
-  Where,
-} from '../../../../domain'
-import { is, isNil, isObject } from '../../../../utils'
-import { HasuraGraphQLColumnType, HasuraGraphQLWhere } from '../../enums'
-import { ColumnOptions, HasuraGraphQLFields, VariableOptions } from '../../types'
-
-import { AttributeOptionHelper } from './attribute-option.helper'
-import { FilterOptionHelper } from './filter-option.helper'
-
-export class BindFilterQueryHelper {
-  static MakeGraphQLWhere = <MBase extends ModelBaseStructure<MBase>>(
-    filter: RepositoryFindFielters<MBase>,
-    fields: HasuraGraphQLFields<MBase>,
-  ): VariableOptions =>
-    Object.keys(filter).reduce((variables: VariableOptions, fieldName: string) => {
-      const columnOption = AttributeOptionHelper.FindByAttribute(
-        fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,
-        fields,
-      )
-
-      if (!columnOption.bindFindFilter)
-        return {
-          ...variables,
-          ...{
-            [columnOption.columnName]: BindFilterQueryHelper.BuildWhereSentence(
-              fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,
-              filter[fieldName as NonFunctionAndIdentifierPropertyNames<MBase>] as RepositoryFindFieltersOptions<
-                MBase,
-                NonFunctionAndIdentifierPropertyNames<MBase>
-              >,
-              fields,
-            ),
-          },
-        }
-
-      const builtFilter: RepositoryFindFielters<MBase> = columnOption.bindFindFilter(
-        filter[fieldName as NonFunctionPropertyNames<MBase>] as RepositoryFindFieltersOptions<
-          MBase,
-          NonFunctionPropertyNames<MBase>
-        >,
-      )
-
-      return {
-        ...variables,
-        ...Object.keys(builtFilter).reduce(
-          (variablesList: VariableOptions, columnName: string) => ({
-            ...variablesList,
-            [columnName]: BindFilterQueryHelper.BuildWhereSentence(
-              fieldName as NonFunctionAndIdentifierPropertyNames<MBase>,
-              builtFilter[columnName as NonFunctionAndIdentifierPropertyNames<MBase>] as RepositoryFindFieltersOptions<
-                MBase,
-                NonFunctionAndIdentifierPropertyNames<MBase>
-              >,
-              fields,
-            ),
-          }),
-          {},
-        ),
-      }
-    }, {})
-
-  static BuildWhereSentence = <MBase extends ModelBaseStructure<MBase>>(
-    field: NonFunctionAndIdentifierPropertyNames<MBase>,
-    options: RepositoryFindFieltersOptions<MBase, NonFunctionAndIdentifierPropertyNames<MBase>>,
-    fields: HasuraGraphQLFields<MBase>,
-  ): VariableOptions => {
-    const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute<MBase>(field, fields)
-    const isNestedField =
-      !Array.isArray(options) &&
-      isObject(options) &&
-      isNil(options?.operator) &&
-      isNil(options?.value) &&
-      isNil(fieldSentenceOptions?.to)
-
-    if (isNestedField)
-      return Object.keys(options).reduce((variables, key) => {
-        const fieldOptions = AttributeOptionHelper.FindByAttribute<MBase>(
-          key as NonFunctionAndIdentifierPropertyNames<MBase>,
-          fieldSentenceOptions?.fields || (fields as any),
-        )
-        const columnName = fieldOptions.columnName
-        const columnFields = fieldOptions.fields
-
-        return {
-          ...variables,
-          [columnName]: BindFilterQueryHelper.BuildWhereSentence<MBase>(
-            key as NonFunctionAndIdentifierPropertyNames<MBase>,
-            is<RepositoryFindFieltersOptions<MBase, NonFunctionAndIdentifierPropertyNames<MBase>>>(
-              is<RepositoryFindFielters<MBase>>(options)[key as NonFunctionAndIdentifierPropertyNames<MBase>],
-            ),
-            fieldSentenceOptions?.fields || columnFields || (fields as any),
-          ),
-        }
-      }, {})
-
-    if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
-      return {
-        [fieldSentenceOptions.fields[0] as NonFunctionAndIdentifierPropertyNames<MBase>]:
-          BindFilterQueryHelper.BuildOperatorSentence(
-            options,
-            fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,
-          ),
-      }
-
-    if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
-      options = Object.values(options)[0] as RepositoryFindFieltersOptions<MBase, any>
-
-    return Array.isArray(options)
-      ? options.reduce(
-        (whereSentence, option) => ({
-          ...whereSentence,
-          ...BindFilterQueryHelper.BuildOperatorSentence(
-            option,
-              fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,
-          ),
-        }),
-        {},
-      )
-      : BindFilterQueryHelper.BuildOperatorSentence(
-        options,
-          fieldSentenceOptions as ColumnOptions<MBase[NonFunctionAndIdentifierPropertyNames<MBase>], MBase>,
-      )
-  }
-
-  static BuildOperatorSentence = <MBase extends ModelBaseStructure<MBase>>(
-    options: RepositoryFindFieltersOptions<MBase, any>,
-    fieldOption: ColumnOptions<any, any>,
-  ): VariableOptions => ({
-    [BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)]: FilterOptionHelper.GetValueFromFilter(
-      options,
-      fieldOption,
-    ),
-  })
-
-  static GetHasuraOperator = <MBase extends ModelBaseStructure<MBase>>(
-    options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase>>,
-    fieldOption: ColumnOptions<any, any>,
-  ): HasuraGraphQLWhere =>
-    FilterOptionHelper.CheckIfIsFilterOption(options)
-      ? fieldOption.type === HasuraGraphQLColumnType.Jsonb
-        ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)
-        : options.operator === Where.LIKE && options.ignoreCase && options.ignoreAccent
-          ? HasuraGraphQLWhere.IREGEX
-          : options.operator === Where.LIKE && options.ignoreAccent
-            ? HasuraGraphQLWhere.REGEX
-            : options.operator === Where.LIKE && options.ignoreCase
-              ? HasuraGraphQLWhere.ILIKE
-              : HasuraGraphQLWhere[
-            Object.keys(HasuraGraphQLWhere).find(
-              (graphQLOperator) =>
-                graphQLOperator ===
-                Object.keys(Where).find((operator) => Where[operator as keyof typeof Where] === options?.operator),
-            ) as keyof typeof HasuraGraphQLWhere
-              ]
-      : HasuraGraphQLWhere.EQUALS
-
-  static GetHasuraJsonbOperator = <MBase extends ModelBaseStructure<MBase>>(
-    options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase>>,
-  ): HasuraGraphQLWhere =>
-    options.operator === Where.IN
-      ? HasuraGraphQLWhere.JSON_CONTAINS
-      : options.operator === Where.LIKE
-        ? HasuraGraphQLWhere.JSON_HAS_KEYS_ANY
-        : HasuraGraphQLWhere[
-          Object.keys(HasuraGraphQLWhere).find(
-            (graphQLOperator) =>
-              graphQLOperator ===
-              Object.keys(Where).find((operator) => Where[operator as keyof typeof Where] === options?.operator),
-          ) as keyof typeof HasuraGraphQLWhere
-        ]
-}

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

@@ -1,14 +0,0 @@
-import { BaseModelBuilder, ModelBaseStructure } from '../../../../domain'
-
-export class CacheKeyGeneratorHelper {
-  static generateCacheKeyFromIdentifiers<MBase extends ModelBaseStructure<MBase>>(
-    modelOrModelName: BaseModelBuilder<MBase> | { name: string },
-    identifiers: Record<string, any>,
-  ): string {
-    const sortedKeys = Object.keys(identifiers).sort()
-    const keyParts = sortedKeys.map((key) => `${String(key)}:${identifiers[key]}`)
-    const modelName = (modelOrModelName as any).name.toLowerCase()
-
-    return `${modelName}:get:${keyParts.join(':')}`
-  }
-}