@infrab4a/connect 5.7.2 → 5.7.3

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

@@ -0,0 +1,66 @@
+import {
+  BaseModelBuilder,
+  CacheConfig,
+  FindRepositoryParams,
+  ModelBaseStructure,
+  RepositoryCacheOptions,
+} from '../../../../../domain'
+import { deserialize, serialize } from '../../../../../utils'
+import { MD5GeneratorHelper } from '../md5-generator.helper'
+
+export class HasuraFindCacheHelper {
+  static generateCacheKey<MBase extends ModelBaseStructure<MBase>>(
+    model: BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>,
+    params?: FindRepositoryParams<MBase>,
+  ): string {
+    const md5 = MD5GeneratorHelper.generateMD5(params)
+
+    return `${model.name.toLowerCase()}:find:${md5}`
+  }
+
+  static async getCachedResult<MBase extends ModelBaseStructure<MBase>>(params: {
+    cache?: CacheConfig
+    model: BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>
+    findParams?: FindRepositoryParams<MBase>
+    cacheOptions?: RepositoryCacheOptions
+    logger?: any
+  }): Promise<any | null> {
+    const { cache, model, findParams, cacheOptions, logger } = params
+
+    if (!cache?.cacheAdapter || !cacheOptions?.enabled) return null
+
+    const cacheKey = this.generateCacheKey(model, findParams)
+    const cachedData = await cache.cacheAdapter.get<string>(cacheKey)
+
+    if (cachedData) {
+      logger?.log(`Dados recuperados do cache: ${cacheKey}`)
+
+      return deserialize(cachedData)
+    }
+
+    return null
+  }
+
+  static async setCachedResult<MBase extends ModelBaseStructure<MBase>>(params: {
+    cache?: CacheConfig
+    model: BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>
+    findParams?: FindRepositoryParams<MBase>
+    cacheOptions?: RepositoryCacheOptions
+    result: any
+    logger?: any
+  }): Promise<void> {
+    const { cache, model, findParams, cacheOptions, result, logger } = params
+
+    if (!cache?.cacheAdapter || !cacheOptions?.enabled) return
+
+    const cacheKey = this.generateCacheKey(model, findParams)
+
+    await cache.cacheAdapter.set({
+      key: cacheKey,
+      data: serialize(result),
+      expirationInSeconds: cacheOptions?.ttl || cache.ttlDefault,
+    })
+
+    logger?.log(`Dados salvos no cache: ${cacheKey}`)
+  }
+}

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

@@ -0,0 +1,89 @@
+import {
+  BaseModelBuilder,
+  FindRepositoryParams,
+  ModelBaseStructure,
+  RepositoryCacheOptions,
+  RepositoryFindResult,
+} from '../../../../../domain'
+import { DebugHelper } from '../../../../../utils'
+import { GraphQLParams, HasuraGraphQLFields } from '../../../types'
+
+import { HasuraFindCacheHelper } from './hasura-find-cache.helper'
+import { HasuraFindQueryBuilderHelper } from './hasura-find-query-builder.helper'
+import { HasuraFindResultHelper } from './hasura-find-result.helper'
+
+export interface ExecuteFindParams<MBase extends ModelBaseStructure<MBase>> {
+  params?: FindRepositoryParams<MBase>
+  cacheOptions?: { cache?: RepositoryCacheOptions }
+  model: BaseModelBuilder<MBase, any, MBase & { prototype: unknown }>
+  tableName: string
+  fields: HasuraGraphQLFields<MBase>
+  cache?: any
+  query: (queries: GraphQLParams<MBase>[]) => Promise<any>
+  convertDataFromHasura: (data: any) => MBase
+  lastDistinct: Record<string, any>
+}
+
+export class HasuraFindOperationsHelper {
+  static async executeFindOperation<MBase extends ModelBaseStructure<MBase>>(
+    operationParams: ExecuteFindParams<MBase>,
+  ): Promise<RepositoryFindResult<MBase>> {
+    const { params, cacheOptions, model, tableName, fields, cache, query, convertDataFromHasura, lastDistinct } =
+      operationParams
+
+    const logger = DebugHelper.from(operationParams, 'find')
+    const { filters, options: findOptions } = params || {}
+    const tableFiltersNamed = `${tableName}:${JSON.stringify(filters)}`
+    const enableCount = findOptions?.enableCount ?? true
+
+    const cachedResult = await HasuraFindCacheHelper.getCachedResult({
+      cache,
+      model,
+      findParams: params,
+      cacheOptions: cacheOptions?.cache,
+      logger,
+    })
+
+    if (cachedResult) {
+      return HasuraFindResultHelper.processResult({
+        result: cachedResult,
+        tableName,
+        enableCount,
+        findOptions,
+        tableFiltersNamed,
+        fields,
+        convertDataFromHasura,
+        lastDistinct,
+      })
+    }
+
+    const queries = HasuraFindQueryBuilderHelper.buildCompleteQuery({
+      tableName,
+      fields,
+      params,
+      lastDistinct,
+    })
+
+    const result = await query(queries)
+
+    await HasuraFindCacheHelper.setCachedResult({
+      cache,
+      model,
+      findParams: params,
+      cacheOptions: cacheOptions?.cache,
+      result,
+      logger,
+    })
+
+    return HasuraFindResultHelper.processResult({
+      result,
+      tableName,
+      enableCount,
+      findOptions,
+      tableFiltersNamed,
+      fields,
+      convertDataFromHasura,
+      lastDistinct,
+    })
+  }
+}

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

@@ -0,0 +1,130 @@
+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, fields }),
+      ...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>
+    fields: HasuraGraphQLFields<MBase>
+  }): 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: params.fields,
+      }),
+    ]
+
+    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,199 @@
+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
+
+    const convertFieldName = (fieldName: NonFunctionAndIdentifierPropertyNames<MBase> | any) => {
+      const finalFieldName = fieldName.toString().split('.').pop()
+
+      const fieldOption = fields.find((fieldOption) => {
+        if (typeof fieldOption === 'string') return fieldOption === finalFieldName
+        const key = Object.keys(fieldOption)[0]
+
+        return key === finalFieldName
+      })
+
+      if (fieldOption && typeof fieldOption !== 'string') {
+        const fieldValue = Object.values(fieldOption)[0]
+
+        return fieldValue?.columnName || finalFieldName
+      }
+
+      return finalFieldName
+    }
+
+    return [
+      ...(aggregates?.minimal?.length
+        ? [
+            {
+              min: aggregates.minimal.map(convertFieldName),
+            },
+          ]
+        : []),
+      ...(aggregates?.maximum?.length
+        ? [
+            {
+              max: aggregates.maximum.map(convertFieldName),
+            },
+          ]
+        : []),
+    ]
+  }
+
+  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) => {
+            const columnName =
+              AttributeOptionHelper.FindByAttribute(
+                current.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>,
+                fields,
+              )?.columnName || current
+
+            return {
+              ...(minimals as any),
+              ...set(
+                minimals as any,
+                current as any,
+                result[`${tableName}_aggregate`].aggregate.min[columnName as string],
+              ),
+            }
+          }, {}) 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) => {
+            const columnName =
+              AttributeOptionHelper.FindByAttribute(
+                current.toString().split('.').pop() as NonFunctionAndIdentifierPropertyNames<MBase>,
+                fields,
+              )?.columnName || current
+
+            return {
+              ...(maximums as any),
+              ...set(
+                maximums as any,
+                current as any,
+                result[`${tableName}_aggregate`].aggregate.max[columnName as string],
+              ),
+            }
+          }, {}) 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}`)
+  }
+}