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

package/src/infra/hasura-graphql/repositories/catalog/wishlist-hasura-graphql.repository.ts

@@ -1,375 +0,0 @@
-import {
-  Category,
-  CategoryMetadata,
-  CreateRepositoryParams,
-  FindRepositoryParams,
-  GetRepositoryParams,
-  PersonTypes,
-  Product,
-  RepositoryFindResult,
-  Shops,
-  UpdateRepositoryParams,
-  Where,
-  Wishlist,
-  WishlistRepository,
-} from '../../../../domain'
-import { DuplicatedResultsError, NotFoundError } from '../../../../errors'
-import { Base, Log, omit } from '../../../../utils'
-import { HasuraGraphQLColumnType } from '../../enums'
-import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
-import { CategoryHasuraGraphQL } from '../../models'
-import { WishlistHasuraGraphQL } from '../../models/wishlist-hasura-graphql'
-import { HasuraGraphQLFields } from '../../types'
-
-import { CategoryProductHasuraGraphQLRepository } from './category-product-hasura-graphql.repository'
-
-const fieldsConfiguration: HasuraGraphQLFields<WishlistHasuraGraphQL> = [
-  { id: { columnName: 'id', to: (value: string) => +value, from: (value) => value.toString() } },
-  { firestoreId: { columnName: 'firestore_id' } },
-  'name',
-  'description',
-  'image',
-  'published',
-  'shop',
-  { shops: { columnName: 'shops', type: HasuraGraphQLColumnType.Jsonb } },
-  'slug',
-  { brandCategory: { columnName: 'brand_category' } },
-  { brandCategoryBanner: { columnName: 'brand_banner' } },
-  { brandCategoryBannerMobile: { columnName: 'brand_banner_mobile' } },
-  { brandLogo: { columnName: 'brand_logo' } },
-  { brandCondition: { columnName: 'brand_condition' } },
-  {
-    conditions: {
-      columnName: 'tag_condition',
-      type: HasuraGraphQLColumnType.Jsonb,
-      from: (tags: unknown, row) => ({ brand: row.brand_condition, tags: Array.isArray(tags) ? tags : [] }),
-      bindPersistData: (value: CategoryHasuraGraphQL['conditions']) => {
-        return {
-          brand_condition: value.brand,
-          tag_condition: value?.tags || [],
-        }
-      },
-      bindFindFilter: (sentence: any) => {
-        return {
-          ...(sentence.brand ? { brand_condition: sentence.brand } : {}),
-          ...(sentence.tags ? { tag_condition: sentence.tags } : {}),
-        }
-      },
-    },
-  },
-  {
-    filters: {
-      columnName: 'filters',
-      foreignKeyColumn: { filter_id: 'id' },
-      fields: [{ filter: ['id', 'description', 'slug', 'enabled'] }],
-      bindPersistData: (value: CategoryHasuraGraphQL['filters']) => ({
-        filters: { data: value.map((filter) => ({ filter_id: filter.id })) },
-      }),
-      from: (filters: { filter: { id: number; description: string; slug: string; enabled: boolean } }[]) =>
-        filters?.map((filter) => filter?.filter) || [],
-    },
-  },
-  { createdAt: { columnName: 'created_at' } },
-  { updatedAt: { columnName: 'updated_at' } },
-  {
-    products: {
-      columnName: 'products',
-      fields: ['product_id'],
-      from: (value: { product_id: number }[]) => value.map((product) => product.product_id.toString()),
-      to: (productIds: string[]) =>
-        productIds.map((productId) => ({
-          product_id: +productId,
-        })),
-    },
-  },
-  {
-    metadata: {
-      columnName: 'metadata',
-      fields: ['shop', 'title', 'description'],
-      bindPersistData: (value: CategoryHasuraGraphQL['metadata']) => ({
-        metadata: { data: value },
-      }),
-    },
-  },
-  {
-    metadatas: {
-      columnName: 'metadatas',
-      fields: ['shop', 'title', 'description'],
-      bindPersistData: (value: CategoryHasuraGraphQL['metadatas']) => ({
-        metadatas: { data: value },
-      }),
-    },
-  },
-  { isCollection: { columnName: 'is_collection' } },
-  { isWishlist: { columnName: 'is_wishlist' } },
-  'reference',
-  { parentId: { columnName: 'parent_id' } },
-  {
-    parent: {
-      columnName: 'parent',
-      foreignKeyColumn: { id: 'parentId' },
-      fields: ['id', 'name', 'reference', 'slug'],
-    },
-  },
-  { personId: { columnName: 'person_id' } },
-  { personName: { columnName: 'person_name' } },
-  { personPhoto: { columnName: 'person_photo' } },
-  { personType: { columnName: 'person_type' } },
-  { personIsSubscriber: { columnName: 'person_is_subscriber' } },
-  'theme',
-  { bannerUrl: { columnName: 'banner_url' } },
-  { personHasPhoto: { columnName: 'person_has_photo' } },
-  { mostRelevants: { columnName: 'most_relevants', type: HasuraGraphQLColumnType.Jsonb } },
-]
-
-export class WishlistHasuraGraphQLRepository
-  extends withCrudHasuraGraphQL(withHasuraGraphQL<WishlistHasuraGraphQL>(Base))
-  implements WishlistRepository
-{
-  constructor(
-    {
-      endpoint,
-      authOptions,
-      interceptors,
-      cache,
-    }: Pick<HasuraConstructorParams<Wishlist>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>,
-    private readonly categoryProductRepository: CategoryProductHasuraGraphQLRepository,
-  ) {
-    super({
-      tableName: 'category',
-      model: WishlistHasuraGraphQL,
-      endpoint,
-      authOptions,
-      interceptors,
-      cache,
-      fields: fieldsConfiguration,
-    })
-  }
-
-  override async create(params: CreateRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL> {
-    const { images, mostRelevants, metadatas, ...data } = params
-
-    return super.create({
-      ...data,
-      isWishlist: true,
-      isCollection: true,
-      brandCategory: false,
-      metadatas: metadatas || [{ shop: data.shop ?? null, description: data.description, title: data.name }],
-      mostRelevants: mostRelevants || {
-        [Shops.GLAMSHOP]: null,
-        [Shops.MENSMARKET]: null,
-      },
-      images: images || {
-        [Shops.GLAMSHOP]: {
-          brandBanner: null,
-          brandBannerMobile: null,
-          image: null,
-        },
-        [Shops.MENSMARKET]: {
-          brandBanner: null,
-          brandBannerMobile: null,
-          image: null,
-        },
-      },
-    })
-  }
-
-  override async get(identifiers: GetRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL> {
-    const data = await super.get(identifiers)
-
-    if (!data.isWishlist) throw new NotFoundError(`Category with id ${identifiers.id} is not a wishlist`)
-
-    return data
-  }
-
-  override async find(
-    params?: FindRepositoryParams<WishlistHasuraGraphQL>,
-  ): Promise<RepositoryFindResult<WishlistHasuraGraphQL>> {
-    const { filters, ...rest } = params
-
-    return await super.find({
-      ...rest,
-      filters: {
-        ...filters,
-        isWishlist: { operator: Where.EQUALS, value: true },
-      },
-    })
-  }
-
-  override async update(params: UpdateRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL> {
-    const { id: checkId, metadatas, ...data } = omit(params, ['products', 'filters'])
-    const plainData = this.paramsToPlain({ id: checkId })
-    const id = plainData.id
-    const category = await super.update({ id, ...data, isWishlist: true, isCollection: true, brandCategory: false })
-
-    category.metadatas = metadatas && (await this.updateMetadata(+id, { metadatas }))
-
-    return category
-  }
-
-  @Log()
-  async getWishlistBySlug(slug: string): Promise<WishlistHasuraGraphQL> {
-    if (!slug) return
-
-    const { data } = await this.find({
-      filters: {
-        slug,
-        isWishlist: { operator: Where.EQUALS, value: true },
-      },
-      options: {
-        enableCount: false,
-      },
-    })
-
-    if (!data.length) throw new NotFoundError(`Wishlist with slug ${slug} not found`)
-
-    if (data.length > 1) throw new DuplicatedResultsError('Query returned duplicated values')
-
-    return data.shift()
-  }
-
-  @Log()
-  async getWishlistByPerson(personId: string): Promise<WishlistHasuraGraphQL[]> {
-    if (!personId) return
-
-    const { data } = await this.find({
-      filters: {
-        personId: { operator: Where.EQUALS, value: personId },
-        isWishlist: { operator: Where.EQUALS, value: true },
-      },
-      options: {
-        enableCount: false,
-      },
-      orderBy: {
-        id: 'asc',
-      },
-      limits: {
-        limit: 1,
-      },
-    })
-
-    if (!data.length) throw new NotFoundError(`Wishlists from person ${personId} not found`)
-
-    return data
-  }
-
-  async getCategoryBySlug(slug: string, _shop: Shops): Promise<Wishlist> {
-    return this.getWishlistBySlug(slug)
-  }
-
-  @Log()
-  async getCategoryByShop(shop: string): Promise<any> {
-    if (!shop) return
-
-    const { data } = await this.find({
-      filters: {
-        shops: { operator: Where.IN, value: [shop] },
-        published: { operator: Where.EQUALS, value: true },
-        isWishlist: { operator: Where.EQUALS, value: true },
-      },
-      options: {
-        enableCount: false,
-      },
-    })
-
-    return data
-  }
-
-  @Log()
-  async findBfluOrGlamgirlWishlists(
-    params: FindRepositoryParams<WishlistHasuraGraphQL>,
-    shops: Shops[],
-  ): Promise<RepositoryFindResult<WishlistHasuraGraphQL>> {
-    return this.find({
-      ...params,
-      filters: {
-        ...params.filters,
-        published: true,
-        shops: { operator: Where.LIKE, value: shops },
-        personType: params.filters?.personType ?? {
-          operator: Where.IN,
-          value: [PersonTypes.BFLU, PersonTypes.GLAMGIRL],
-        },
-      },
-      orderBy: {
-        personHasPhoto: 'desc',
-        ...omit(params.orderBy, ['personHasPhoto']),
-      },
-    })
-  }
-
-  getCategoriesForHome(): Promise<{ category: Category; products: Product[] }[]> {
-    return
-  }
-
-  mountCategory(): Promise<Product[]> {
-    return
-  }
-
-  getChildren(_parentId: number): Promise<Category[]> {
-    return
-  }
-
-  isChild(_id: number, _parentId: number): Promise<boolean> {
-    return
-  }
-
-  private async updateMetadata(
-    categoryId: number,
-    { metadatas }: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'metadatas'>,
-  ): Promise<CategoryMetadata[]> {
-    if (Array.isArray(metadatas) && !metadatas.length) return []
-
-    if (Array.isArray(metadatas) && metadatas.length) {
-      const metadataUpdated = []
-
-      for (const data of metadatas) {
-        const update = await this.mutation('update_category_metadata_by_pk', ['category_id', 'shop'], {
-          pk_columns: {
-            value: { category_id: categoryId, shop: data.shop },
-            type: 'category_metadata_pk_columns_input',
-            required: true,
-          },
-          _set: {
-            value: omit(data, ['category_id', 'shop']),
-            type: 'category_metadata_set_input',
-            required: true,
-          },
-        })
-
-        metadataUpdated.push(update)
-      }
-
-      return metadataUpdated
-    }
-
-    if ('action' in metadatas && metadatas.action === 'remove' && metadatas.value.length) {
-      for (let i = 0; i < metadatas.value.length; i++) {
-        await this.mutation('delete_category_metadata', ['affected_rows'], {
-          where: {
-            type: 'category_metadata_bool_exp',
-            required: true,
-            value: { category_id: { _eq: categoryId }, shop: metadatas.value[i].shop },
-          },
-        })
-      }
-
-      return []
-    }
-  }
-
-  async addProduct(wishlistId: string, productId: string): Promise<void> {
-    await this.categoryProductRepository.create({
-      categoryId: +wishlistId,
-      productId: +productId,
-      order: 0,
-    })
-  }
-
-  async removeProduct(wishlistId: string, productId: string): Promise<void> {
-    return this.categoryProductRepository.delete({
-      categoryId: +wishlistId,
-      productId: +productId,
-    })
-  }
-}

package/src/infra/hasura-graphql/repositories/index.ts

@@ -1 +0,0 @@
-export * from './catalog'

package/src/infra/hasura-graphql/types/fields.type.ts

@@ -1,3 +0,0 @@
-import { NestedField } from './nested-field.type'
-
-export type Fields = Array<string | object | NestedField | 'aggregate' | 'nodes'>

package/src/infra/hasura-graphql/types/graphql.repository.type.ts

@@ -1,37 +0,0 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions'
-
-import { BaseModelBuilder, CacheConfig, ModelBaseStructure } from '../../../domain'
-import { DebugHelper } from '../../../utils'
-
-import { HasuraGraphQLAuthOptions } from './hasura-graphql-auth-options.type'
-import { HasuraGraphQLFields } from './hasura-graphql-fields.type'
-import { VariableOptions } from './variable-options.type'
-
-export type GraphQLParams<Model extends ModelBaseStructure<Model>> = {
-  operation: string | IOperation
-  fields?: HasuraGraphQLFields<Model>
-  variables?: VariableOptions
-}
-
-export type GraphQLRepository<Model extends ModelBaseStructure<Model>> = {
-  tableName: string
-  model: BaseModelBuilder<Model>
-  fields: HasuraGraphQLFields<Model>
-  endpoint: string
-  authOptions: HasuraGraphQLAuthOptions
-  logger: DebugHelper
-  cache?: CacheConfig
-  mutation: <ReturnFields = any>(
-    operation: string | IOperation,
-    fields?: string[] | HasuraGraphQLFields<Model>,
-    variables?: VariableOptions,
-  ) => Promise<ReturnFields>
-  query: <ReturnFields = any>(
-    operation: string | IOperation | GraphQLParams<Model>[],
-    fields?: string[] | HasuraGraphQLFields<Model>,
-    variables?: VariableOptions,
-  ) => Promise<ReturnFields>
-  getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string
-  convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<Model>): Model
-  convertDataToHasura(instance: Model, update?: boolean): Record<string, string | number>
-}

package/src/infra/hasura-graphql/types/hasura-graphql-auth-options.type.ts

@@ -1,8 +0,0 @@
-export type HasuraGraphQLAuthOptions = {
-  adminSecret?: string
-  authRole?: {
-    role: string
-    userId: string
-  }
-  authToken?: string
-}

package/src/infra/hasura-graphql/types/hasura-graphql-fields.type.ts

@@ -1,90 +0,0 @@
-import {
-  ModelBaseStructure,
-  NestedRepositoryFindFieltersOptions,
-  NonFunctionAndIdentifierPropertyNames,
-  RepositoryFindField,
-} from '../../../domain'
-import { PropType } from '../../../utils'
-import { HasuraGraphQLColumnType } from '../enums'
-
-export type ColumnOptions<FieldType, Model, ValueFrom = any> = {
-  type?: HasuraGraphQLColumnType
-  columnName?: string
-  filters?: {
-    filterType: HasuraGraphQLColumnType | string
-    filters: NestedRepositoryFindFieltersOptions<FieldType>
-  }
-  fields?: HasuraGraphQLFields<FieldType>
-  foreignKeyColumn?:
-    | Partial<
-        Record<
-          NonFunctionAndIdentifierPropertyNames<FieldType extends any[] ? FieldType[number] : FieldType>,
-          NonFunctionAndIdentifierPropertyNames<Model> | (string & {})
-        >
-      >
-    | {}
-  from?: (value: ValueFrom | ValueFrom[], data?: any) => FieldType
-  to?: (value: FieldType, instance?: Model) => ValueFrom
-  bindFindFilter?: (
-    sentence: RepositoryFindField<Model, keyof Model>,
-  ) => Record<string, RepositoryFindField<any, any> | ValueFrom> | RepositoryFindField<any, any> | ValueFrom
-  bindPersistData?: (value: FieldType, instance?: Model) => Record<string, ValueFrom>
-}
-export type AggregateOptionNames =
-  | 'avg'
-  | 'count'
-  | 'max'
-  | 'min'
-  | 'stddev'
-  | 'stddev_pop'
-  | 'stddev_samp'
-  | 'sum'
-  | 'var_pop'
-  | 'var_samp'
-  | 'variance'
-export type AggregateOptionFields<Model, Type, Properties extends keyof Model = keyof Model> =
-  | {
-      [K in Properties]: PropType<Model, K> extends Type ? K : never
-    }[Properties]
-  | string
-export type AggregateOptions<Model> = {
-  avg?: Array<AggregateOptionFields<Model, number>>
-  max?: Array<AggregateOptionFields<Model, number | Date>>
-  min?: Array<AggregateOptionFields<Model, number | Date>>
-  stddev?: Array<AggregateOptionFields<Model, number>>
-  stddev_pop?: Array<AggregateOptionFields<Model, number>>
-  stddev_samp?: Array<AggregateOptionFields<Model, number>>
-  sum?: Array<AggregateOptionFields<Model, number>>
-  var_pop?: Array<AggregateOptionFields<Model, number>>
-  var_samp?: Array<AggregateOptionFields<Model, number>>
-  variance?: Array<AggregateOptionFields<Model, number>>
-}
-
-type ModelBaseHasuraGraphQLFields<Model> = Model extends ModelBaseStructure
-  ?
-      | NonFunctionAndIdentifierPropertyNames<Model>
-      | {
-          [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure
-            ? HasuraGraphQLFields<PropType<Model, key>>
-            : PropType<Model, key> extends any[]
-            ? PropType<Model, key>[] extends ModelBaseStructure[]
-              ? HasuraGraphQLFields<PropType<Model, key>[]>
-              : never
-            : never
-        }
-      | {
-          [key in NonFunctionAndIdentifierPropertyNames<Model>]?: key extends 'aggregate'
-            ? never
-            : PropType<Model, key> extends ModelBaseStructure
-            ? ColumnOptions<PropType<Model, key>, Model>
-            : ColumnOptions<PropType<Model, key>, Model>
-        }
-      | Record<string, ColumnOptions<PropType<Model, any>, Model>>
-  : string
-
-export type HasuraGraphQLFields<Model> = (
-  | ModelBaseHasuraGraphQLFields<Model>
-  | { aggregate: Array<AggregateOptions<Model> | 'count'> }
-  | { returning: NonFunctionAndIdentifierPropertyNames<Model>[] }
-  | 'affected_rows'
-)[]

package/src/infra/hasura-graphql/types/hasura-graphql-headers.type.ts

@@ -1,7 +0,0 @@
-export type HasuraGraphQLHeaders = {
-  Authorization?: string
-  'Content-Type': string
-  'X-Hasura-Admin-Secret'?: string
-  'X-Hasura-Role'?: string
-  'X-Hasura-User-Id'?: string
-}

package/src/infra/hasura-graphql/types/index.ts

@@ -1,8 +0,0 @@
-export * from './fields.type'
-export * from './graphql.repository.type'
-export * from './nested-field.type'
-export * from './query-builder-options.type'
-export * from './variable-options.type'
-export * from './hasura-graphql-auth-options.type'
-export * from './hasura-graphql-fields.type'
-export * from './hasura-graphql-headers.type'

package/src/infra/hasura-graphql/types/nested-field.type.ts

@@ -1,8 +0,0 @@
-import { Fields } from './fields.type'
-import { QueryBuilderOptions } from './query-builder-options.type'
-
-export type NestedField = {
-  operation: string
-  variables: QueryBuilderOptions[]
-  fields: Fields
-}

package/src/infra/hasura-graphql/types/query-builder-options.type.ts

@@ -1,8 +0,0 @@
-import { Fields } from './fields.type'
-import { VariableOptions } from './variable-options.type'
-
-export interface QueryBuilderOptions {
-  operation: string
-  fields?: Fields
-  variables?: VariableOptions
-}

package/src/infra/hasura-graphql/types/variable-options.type.ts

@@ -1,11 +0,0 @@
-export type VariableOptions =
-  | {
-      type?: string
-      name?: string
-      value: any
-      list?: boolean
-      required?: boolean
-    }
-  | {
-      [k: string]: any
-    }

package/src/infra/index.ts

@@ -1,7 +0,0 @@
-export * from './adyen'
-export * from './cache'
-export * from './elasticsearch'
-export * from './firebase'
-export * from './hasura-graphql'
-export * from './pagarme'
-export * from './vertex-ai'

package/src/infra/pagarme/adapters/helpers/index.ts

@@ -1,3 +0,0 @@
-export * from './pagarme-blocked-order.helper'
-export * from './pagarme-payment-factory.helper'
-export * from './pagarme-payment-operations.helper'

package/src/infra/pagarme/adapters/helpers/pagarme-blocked-order.helper.ts

@@ -1,45 +0,0 @@
-import { Checkout, PaymentCardInfo } from '../../../../domain'
-import { OrderBlockedRepository } from '../../../../domain/shopping/repositories'
-import { PaymentError } from '../../../../errors'
-
-interface BlockedOrderParams {
-  checkout: Checkout
-  card: PaymentCardInfo
-  orderBlockedRepository: OrderBlockedRepository
-}
-
-export class PagarmeBlockedOrderHelper {
-  static async createBlockedOrderForUnauthorizedCard(params: BlockedOrderParams): Promise<void> {
-    const { checkout, card, orderBlockedRepository } = params
-
-    await orderBlockedRepository.createBlockedOrderOrPayment({
-      checkout,
-      blockType: 'Card not authorized',
-      type: 'Card',
-      limiteRange: 'day',
-      card,
-    })
-  }
-
-  static createPaymentError(checkout: Checkout, resultData: any): PaymentError {
-    return new PaymentError(
-      'Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito',
-      {
-        checkoutId: checkout.id,
-        userEmail: checkout.user.email,
-        info: resultData,
-      },
-    )
-  }
-
-  static createGenericPaymentError(checkout: Checkout, errorResponseData: any): PaymentError {
-    return new PaymentError(
-      'Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito',
-      {
-        checkoutId: checkout.id,
-        userEmail: checkout.user.email,
-        info: errorResponseData,
-      },
-    )
-  }
-}

package/src/infra/pagarme/adapters/helpers/pagarme-payment-factory.helper.ts

@@ -1,27 +0,0 @@
-import { Checkout, Payment } from '../../../../domain'
-import { PaymentProviders } from '../../../../domain/shopping/enums'
-import { PaymentRepository } from '../../../../domain/shopping/repositories'
-
-interface CreatePaymentParams {
-  checkout: Checkout
-  resultData: any
-  paymentRepository: PaymentRepository
-}
-
-export class PagarmePaymentFactoryHelper {
-  static async createSuccessfulPayment(params: CreatePaymentParams): Promise<Payment> {
-    const { checkout, resultData, paymentRepository } = params
-
-    const payment = await paymentRepository.create({
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      userId: checkout.user.id,
-      checkoutId: checkout.id,
-      totalPrice: checkout.totalPrice,
-      paymentProvider: PaymentProviders.PAGARME,
-      transaction: { ...resultData, paidAt: new Date() },
-    })
-
-    return payment
-  }
-}

package/src/infra/pagarme/adapters/helpers/pagarme-payment-operations.helper.ts

@@ -1,29 +0,0 @@
-import axios from 'axios'
-
-import { Checkout, PaymentCardInfo } from '../../../../domain'
-import { PagarmeCredentials } from '../../../../domain/shopping/types'
-
-interface PaymentRequestParams {
-  checkout: Checkout
-  card: PaymentCardInfo
-  credentials: PagarmeCredentials
-  createPayloadFunction: (checkout: Checkout, card: PaymentCardInfo) => any
-}
-
-export class PagarmePaymentOperationsHelper {
-  static async executePaymentRequest(params: PaymentRequestParams): Promise<any> {
-    const { checkout, card, credentials, createPayloadFunction } = params
-
-    const payload = createPayloadFunction(checkout, card)
-
-    console.warn('[PAGARME CARD DATA TO SEND]', payload)
-
-    const result = await axios({
-      method: 'POST',
-      url: `${credentials.URL}/transactions`,
-      data: payload,
-    })
-
-    return result
-  }
-}