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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/infra/index.ts

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

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

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

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

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