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

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

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

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

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

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

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

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

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

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