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

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

@@ -1,129 +0,0 @@
-import { FindRepositoryParams, ModelBaseStructure } from '../../../../../domain'
-import { isNil } from '../../../../../utils'
-import { GraphQLParams, HasuraGraphQLFields } from '../../../types'
-
-import { HasuraFindResultHelper } from './hasura-find-result.helper'
-import { HasuraFindVariablesHelper } from './hasura-find-variables.helper'
-
-export interface BuildQueryParams<MBase extends ModelBaseStructure<MBase>> {
-  tableName: string
-  fields: HasuraGraphQLFields<MBase>
-  params?: FindRepositoryParams<MBase>
-  lastDistinct: Record<string, any>
-}
-
-export class HasuraFindQueryBuilderHelper {
-  static buildCompleteQuery<MBase extends ModelBaseStructure<MBase>>(
-    queryParams: BuildQueryParams<MBase>,
-  ): GraphQLParams<MBase>[] {
-    const { tableName, fields, params, lastDistinct } = queryParams
-    const { filters, limits, orderBy, options: findOptions } = params || {}
-
-    const filtersVariables = HasuraFindVariablesHelper.buildFiltersVariables({ filters, tableName, fields })
-    const countVariables = {
-      ...HasuraFindVariablesHelper.buildOrderByVariables({ orderBy, tableName, fields }),
-      ...filtersVariables,
-    }
-    const mainVariables = {
-      ...(isNil(limits) ? {} : limits),
-      ...countVariables,
-    }
-
-    const queries: GraphQLParams<MBase>[] = [
-      this.buildMainQuery({ tableName, fields, params, mainVariables }),
-      ...this.buildAggregateQuery({ tableName, findOptions, countVariables }),
-      ...this.buildDistinctQueries({ tableName, fields, findOptions, filtersVariables, lastDistinct }),
-    ]
-
-    return queries.filter(Boolean)
-  }
-
-  private static buildMainQuery<MBase extends ModelBaseStructure<MBase>>(params: {
-    tableName: string
-    fields: HasuraGraphQLFields<MBase>
-    params?: FindRepositoryParams<MBase>
-    mainVariables: Record<string, any>
-  }): GraphQLParams<MBase> {
-    const { tableName, fields, params: findParams, mainVariables } = params
-
-    return {
-      operation: tableName,
-      fields: findParams?.fields
-        ? findParams.fields
-            .map(
-              (fieldName) =>
-                fields.find((fieldOption) => fieldOption === fieldName) ??
-                fields.find((fieldOption) => Object.keys(fieldOption).shift() === fieldName),
-            )
-            .filter(Boolean)
-        : fields,
-      variables: mainVariables,
-    }
-  }
-
-  private static buildAggregateQuery<MBase extends ModelBaseStructure<MBase>>(params: {
-    tableName: string
-    findOptions?: FindRepositoryParams<MBase>['options']
-    countVariables: Record<string, any>
-  }): GraphQLParams<MBase>[] {
-    const { tableName, findOptions, countVariables } = params
-    const enableCount = findOptions?.enableCount ?? true
-
-    const aggregateFields = [
-      ...(enableCount ? ['count'] : []),
-      ...HasuraFindResultHelper.bindAggregateAttributes({
-        aggregates: { minimal: findOptions?.minimal, maximum: findOptions?.maximum },
-        fields: [] as any, // será preenchido no contexto correto
-      }),
-    ]
-
-    return aggregateFields.length > 0
-      ? [
-          {
-            operation: `${tableName}_aggregate`,
-            fields: [
-              {
-                aggregate: aggregateFields,
-              },
-            ],
-            variables: countVariables,
-          } as GraphQLParams<MBase>,
-        ]
-      : []
-  }
-
-  private static buildDistinctQueries<MBase extends ModelBaseStructure<MBase>>(params: {
-    tableName: string
-    fields: HasuraGraphQLFields<MBase>
-    findOptions?: FindRepositoryParams<MBase>['options']
-    filtersVariables: Record<string, any>
-    lastDistinct: Record<string, any>
-  }): GraphQLParams<MBase>[] {
-    const { tableName, fields, findOptions, filtersVariables, lastDistinct } = params
-    const tableFiltersNamed = `${tableName}:${JSON.stringify(filtersVariables)}`
-
-    if (!findOptions?.distinct?.length || lastDistinct[tableFiltersNamed]) {
-      return []
-    }
-
-    return findOptions.distinct.map((distinct) => {
-      const distinctOption =
-        fields.find((fieldOption) => fieldOption === distinct) ??
-        fields.find((fieldOption) => Object.keys(fieldOption).shift() === distinct)
-
-      return {
-        operation: {
-          name: tableName,
-          alias: `${tableName}_${distinct.toString()}_distinct`,
-        },
-        fields: [distinctOption],
-        variables: HasuraFindVariablesHelper.buildDistinctVariables({
-          distinct: distinct.toString(),
-          tableName,
-          fields,
-          filtersVariables,
-        }),
-      } as GraphQLParams<MBase>
-    })
-  }
-}

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

@@ -1,180 +0,0 @@
-import {
-  FindRepositoryParams,
-  ModelBaseStructure,
-  NonFunctionAndIdentifierPropertyNames,
-  RepositoryFindResult,
-} from '../../../../../domain'
-import { set } from '../../../../../utils'
-import { HasuraGraphQLFields } from '../../../types'
-import { AttributeOptionHelper } from '../attribute-option.helper'
-
-export interface ProcessResultParams<MBase extends ModelBaseStructure<MBase>> {
-  result: any
-  tableName: string
-  enableCount: boolean
-  findOptions: FindRepositoryParams<MBase>['options']
-  tableFiltersNamed: string
-  fields: HasuraGraphQLFields<MBase>
-  convertDataFromHasura: (data: any) => MBase
-  lastDistinct: Record<string, any>
-}
-
-export class HasuraFindResultHelper {
-  static processResult<MBase extends ModelBaseStructure<MBase>>(
-    params: ProcessResultParams<MBase>,
-  ): RepositoryFindResult<MBase> {
-    const {
-      result,
-      tableName,
-      enableCount,
-      findOptions,
-      tableFiltersNamed,
-      fields,
-      convertDataFromHasura,
-      lastDistinct,
-    } = params
-
-    const data: MBase[] = result[tableName].map((row: Record<string, string | number>) => convertDataFromHasura(row))
-
-    const findResult = {
-      data,
-      count: enableCount ? result[`${tableName}_aggregate`].aggregate.count : Infinity,
-      ...this.processMinimalAggregates({ result, tableName, findOptions, fields }),
-      ...this.processMaximumAggregates({ result, tableName, findOptions, fields }),
-      ...this.processDistinctResults({ result, tableName, findOptions, tableFiltersNamed, fields, lastDistinct }),
-    }
-
-    return findResult
-  }
-
-  static bindAggregateAttributes<MBase extends ModelBaseStructure<MBase>>(params: {
-    aggregates: {
-      minimal?: FindRepositoryParams<MBase>['options']['minimal']
-      maximum?: FindRepositoryParams<MBase>['options']['maximum']
-    }
-    fields: HasuraGraphQLFields<MBase>
-  }): Array<any> {
-    const { aggregates, fields } = params
-
-    return [
-      ...(aggregates?.minimal?.length
-        ? [
-            {
-              min: this.bindAttributesToColumns(aggregates.minimal, fields),
-            },
-          ]
-        : []),
-      ...(aggregates?.maximum?.length
-        ? [
-            {
-              max: this.bindAttributesToColumns(aggregates.maximum, fields),
-            },
-          ]
-        : []),
-    ]
-  }
-
-  private static processMinimalAggregates<MBase extends ModelBaseStructure<MBase>>(params: {
-    result: any
-    tableName: string
-    findOptions: FindRepositoryParams<MBase>['options']
-    fields: HasuraGraphQLFields<MBase>
-  }) {
-    const { result, tableName, findOptions, fields } = params
-
-    return findOptions?.minimal?.length
-      ? {
-          minimal: findOptions.minimal.reduce(
-            (minimals, current) => ({
-              ...(minimals as any),
-              ...set(
-                minimals as any,
-                current as any,
-                result[`${tableName}_aggregate`].aggregate.min[
-                  AttributeOptionHelper.FindByAttribute(
-                    current.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>,
-                    fields,
-                  )?.columnName || (current as any)
-                ],
-              ),
-            }),
-            {},
-          ) as RepositoryFindResult<MBase>['minimal'],
-        }
-      : {}
-  }
-
-  private static processMaximumAggregates<MBase extends ModelBaseStructure<MBase>>(params: {
-    result: any
-    tableName: string
-    findOptions: FindRepositoryParams<MBase>['options']
-    fields: HasuraGraphQLFields<MBase>
-  }) {
-    const { result, tableName, findOptions, fields } = params
-
-    return findOptions?.maximum?.length
-      ? {
-          maximum: findOptions.maximum.reduce(
-            (maximums, current) => ({
-              ...(maximums as any),
-              ...set(
-                maximums as any,
-                current as any,
-                result[`${tableName}_aggregate`].aggregate.max[
-                  AttributeOptionHelper.FindByAttribute(
-                    current.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>,
-                    fields,
-                  )?.columnName || (current as any)
-                ],
-              ),
-            }),
-            {},
-          ) as RepositoryFindResult<MBase>['maximum'],
-        }
-      : {}
-  }
-
-  private static processDistinctResults<MBase extends ModelBaseStructure<MBase>>(params: {
-    result: any
-    tableName: string
-    findOptions: FindRepositoryParams<MBase>['options']
-    tableFiltersNamed: string
-    fields: HasuraGraphQLFields<MBase>
-    lastDistinct: Record<string, any>
-  }) {
-    const { result, tableName, findOptions, tableFiltersNamed, fields, lastDistinct } = params
-
-    return findOptions?.distinct?.length
-      ? {
-          distinct:
-            lastDistinct[tableFiltersNamed] ??
-            (lastDistinct[tableFiltersNamed] = findOptions?.distinct.reduce((distinct, current) => {
-              const distinctOption =
-                fields.find((fieldOption) => fieldOption === current) ??
-                fields.find((fieldOption) => Object.keys(fieldOption).shift() === current)
-              const fieldName = Object.values(distinctOption).shift()?.columnName || current
-
-              return {
-                ...distinct,
-                [current.toString()]: result[`${tableName}_${current.toString()}_distinct`].map(
-                  (obj: Record<string, string | number>) => obj[fieldName],
-                ),
-              }
-            }, {} as any)),
-        }
-      : {}
-  }
-
-  private static bindAttributesToColumns<MBase extends ModelBaseStructure<MBase>>(
-    attributes: Array<NonFunctionAndIdentifierPropertyNames<MBase> | any>,
-    fields: HasuraGraphQLFields<MBase>,
-  ) {
-    return attributes.map(
-      (attr) =>
-        AttributeOptionHelper.FindByAttribute(
-          attr.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>,
-          fields,
-        )?.columnName || attr,
-    )
-  }
-}

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

@@ -1,92 +0,0 @@
-import {
-  FindRepositoryParams,
-  ModelBaseStructure,
-  NonFunctionAndIdentifierPropertyNames,
-  RepositoryOrderBy,
-} from '../../../../../domain'
-import { isNil } from '../../../../../utils'
-import { HasuraGraphQLFields } from '../../../types'
-import { AttributeOptionHelper } from '../attribute-option.helper'
-import { BindFilterQueryHelper } from '../bind-filter-query.helper'
-
-export class HasuraFindVariablesHelper {
-  static buildFiltersVariables<MBase extends ModelBaseStructure<MBase>>(params: {
-    filters: FindRepositoryParams<MBase>['filters']
-    tableName: string
-    fields: HasuraGraphQLFields<MBase>
-  }): Record<string, any> {
-    const { filters, tableName, fields } = params
-
-    return isNil(filters)
-      ? {}
-      : {
-          where: {
-            value: BindFilterQueryHelper.MakeGraphQLWhere(filters, fields),
-            type: `${tableName}_bool_exp`,
-            required: true,
-          },
-        }
-  }
-
-  static buildOrderByVariables<MBase extends ModelBaseStructure<MBase>>(params: {
-    orderBy: RepositoryOrderBy<MBase>
-    tableName: string
-    fields: HasuraGraphQLFields<MBase>
-  }): Record<string, any> {
-    const { orderBy, tableName, fields } = params
-
-    return isNil(orderBy)
-      ? {}
-      : {
-          order_by: {
-            type: `${tableName}_order_by!`,
-            list: true,
-            value: this.bindOrderByAttributes(orderBy, fields),
-          },
-        }
-  }
-
-  static buildDistinctVariables<MBase extends ModelBaseStructure<MBase>>(params: {
-    distinct: string
-    tableName: string
-    fields: HasuraGraphQLFields<MBase>
-    filtersVariables: Record<string, any>
-  }): Record<string, any> {
-    const { distinct, tableName, fields, filtersVariables } = params
-
-    const distinctOption =
-      fields.find((fieldOption) => fieldOption === distinct) ??
-      fields.find((fieldOption) => Object.keys(fieldOption).shift() === distinct)
-    const fieldName = Object.values(distinctOption).shift()?.columnName || distinct
-
-    return {
-      ...filtersVariables,
-      [`${tableName}_${fieldName}_distinct`]: {
-        type: `${tableName}_select_column!`,
-        list: true,
-        value: fieldName,
-        name: 'distinct_on',
-      },
-    }
-  }
-
-  private static bindOrderByAttributes<MBase extends ModelBaseStructure<MBase>>(
-    orderBy: RepositoryOrderBy<MBase>,
-    fields: HasuraGraphQLFields<MBase>,
-  ) {
-    return Object.keys(orderBy).reduce(
-      (acc, current) =>
-        [
-          ...acc,
-          {
-            [AttributeOptionHelper.FindByAttribute(current as NonFunctionAndIdentifierPropertyNames<MBase>, fields)
-              .columnName]:
-              orderBy[current as NonFunctionAndIdentifierPropertyNames<MBase>] === 'asc'
-                ? 'asc_nulls_last'
-                : 'desc_nulls_last',
-          },
-        ] as any,
-      [] as any,
-    )
-  }
-}

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

@@ -1,6 +0,0 @@
-export { HasuraFindBindingHelper } from './hasura-find-binding.helper'
-export { HasuraFindCacheHelper } from './hasura-find-cache.helper'
-export { ExecuteFindParams, HasuraFindOperationsHelper } from './hasura-find-operations.helper'
-export { BuildQueryParams, HasuraFindQueryBuilderHelper } from './hasura-find-query-builder.helper'
-export { HasuraFindResultHelper, ProcessResultParams } from './hasura-find-result.helper'
-export { HasuraFindVariablesHelper } from './hasura-find-variables.helper'

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

@@ -1,59 +0,0 @@
-import { CacheConfig, GetRepositoryParams, ModelBaseStructure, RepositoryCacheOptions } from '../../../../../domain'
-import { DebugHelper, deserialize, serialize } from '../../../../../utils'
-import { CacheKeyGeneratorHelper } from '../cache-key-generator.helper'
-
-export class HasuraGetCacheHelper {
-  static generateCacheKey<MBase extends ModelBaseStructure<MBase>>(
-    model: any,
-    identifiers: GetRepositoryParams<MBase>,
-  ): string {
-    return CacheKeyGeneratorHelper.generateCacheKeyFromIdentifiers(model, identifiers)
-  }
-
-  static async getCachedData<MBase extends ModelBaseStructure<MBase>>(
-    cache: CacheConfig | undefined,
-    params: {
-      identifiers: GetRepositoryParams<MBase>
-      options?: { cache?: RepositoryCacheOptions }
-      model: any
-      logger: DebugHelper
-    },
-  ): Promise<MBase | null> {
-    const { identifiers, options, model, logger } = params
-
-    if (!cache?.cacheAdapter || !options?.cache?.enabled) return null
-
-    const cacheKey = this.generateCacheKey(model, identifiers)
-    const cachedData = await cache.cacheAdapter.get<string>(cacheKey)
-
-    if (!cachedData) return null
-
-    logger.log(`Dados recuperados do cache: ${cacheKey}`)
-
-    return model.toInstance(deserialize(cachedData))
-  }
-
-  static async saveCacheData<MBase extends ModelBaseStructure<MBase>>(
-    cache: CacheConfig | undefined,
-    params: {
-      identifiers: GetRepositoryParams<MBase>
-      options?: { cache?: RepositoryCacheOptions }
-      data: MBase
-      logger: DebugHelper
-    },
-  ): Promise<void> {
-    const { identifiers, options, data, logger } = params
-
-    if (!cache?.cacheAdapter || !options?.cache?.enabled) return
-
-    const cacheKey = this.generateCacheKey(params.data.constructor as any, identifiers)
-
-    await cache.cacheAdapter.set({
-      key: cacheKey,
-      data: serialize(data),
-      expirationInSeconds: options?.cache?.ttl || cache.ttlDefault,
-    })
-
-    logger.log(`Dados salvos no cache: ${cacheKey}`)
-  }
-}

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

@@ -1,84 +0,0 @@
-import { CacheConfig, GetRepositoryParams, ModelBaseStructure, RepositoryCacheOptions } from '../../../../../domain'
-import { NotFoundError } from '../../../../../errors'
-import { DebugHelper, isNil } from '../../../../../utils'
-import { GraphQLRepository, HasuraGraphQLFields } from '../../../types'
-
-import { HasuraGetCacheHelper } from './hasura-get-cache.helper'
-import { HasuraGetVariablesHelper } from './hasura-get-variables.helper'
-
-export type ExecuteGetParams<MBase extends ModelBaseStructure<MBase>> = {
-  identifiers: GetRepositoryParams<MBase>
-  options?: { cache?: RepositoryCacheOptions }
-  repository: GraphQLRepository<MBase>
-  getGraphQLOperation: string
-  fields: HasuraGraphQLFields<MBase>
-  model: any
-  cache?: CacheConfig
-}
-
-export class HasuraGetOperationsHelper {
-  static buildGetOperationName(tableName: string, customOperation?: string): string {
-    return customOperation || `${tableName}_by_pk`
-  }
-
-  static async executeGet<MBase extends ModelBaseStructure<MBase>>(params: ExecuteGetParams<MBase>): Promise<MBase> {
-    const { identifiers, options, repository, getGraphQLOperation, fields, model, cache } = params
-
-    const logger = DebugHelper.from(repository, 'get')
-
-    const cachedData = await HasuraGetCacheHelper.getCachedData(cache, {
-      identifiers,
-      options,
-      model,
-      logger,
-    })
-
-    if (cachedData) return cachedData
-
-    const queryResult = await this.executeQuery({
-      identifiers,
-      repository,
-      getGraphQLOperation,
-      fields,
-      model,
-    })
-
-    const resultModel = repository.convertDataFromHasura(queryResult)
-
-    await HasuraGetCacheHelper.saveCacheData(cache, {
-      identifiers,
-      options,
-      data: resultModel,
-      logger,
-    })
-
-    return resultModel
-  }
-
-  private static async executeQuery<MBase extends ModelBaseStructure<MBase>>(params: {
-    identifiers: GetRepositoryParams<MBase>
-    repository: GraphQLRepository<MBase>
-    getGraphQLOperation: string
-    fields: HasuraGraphQLFields<MBase>
-    model: any
-  }): Promise<any> {
-    const { identifiers, repository, getGraphQLOperation, fields, model } = params
-
-    const variables = HasuraGetVariablesHelper.buildGetVariables(identifiers, {
-      model,
-      fields,
-      repository,
-    })
-
-    const result = await repository.query(getGraphQLOperation, fields, variables)
-    const data = result[getGraphQLOperation]
-
-    if (isNil(data)) {
-      const instance = model.toInstance(identifiers)
-
-      throw new NotFoundError(`${instance.constructor.name} not found`)
-    }
-
-    return data
-  }
-}

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

@@ -1,41 +0,0 @@
-import { GetRepositoryParams, ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../../../domain'
-import { isNil } from '../../../../../utils'
-import { GraphQLRepository, HasuraGraphQLFields } from '../../../types'
-import { AttributeOptionHelper } from '../attribute-option.helper'
-
-export class HasuraGetVariablesHelper {
-  static buildGetVariables<MBase extends ModelBaseStructure<MBase>>(
-    identifiers: GetRepositoryParams<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[identifierBinded])) return ids
-
-      const columnOption = AttributeOptionHelper.FindByAttribute(identifier, fields)
-      const value =
-        columnOption?.to?.(identifiers[identifier as keyof typeof identifiers], instance) ||
-        identifiers[identifier as keyof typeof identifiers]
-
-      return {
-        ...ids,
-        [columnOption.columnName]: {
-          type: repository.getAttributeGraphQLTypeOf(columnOption.type || value),
-          value,
-          required: true,
-        },
-      }
-    }, {})
-  }
-}

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

@@ -1,3 +0,0 @@
-export { HasuraGetCacheHelper } from './hasura-get-cache.helper'
-export { ExecuteGetParams, HasuraGetOperationsHelper } from './hasura-get-operations.helper'
-export { HasuraGetVariablesHelper } from './hasura-get-variables.helper'