cloudcommerce 0.31.2 → 0.32.0

package/packages/apps/pagarme-v5/lib/pagarme-v5.js

@@ -0,0 +1,12 @@
+import '@cloudcommerce/firebase/lib/init';
+import handleListPayments from '../lib-mjs/list-pagarme5-payments.mjs';
+import handleCreateTransaction from '../lib-mjs/create-pagarme5-transaction.mjs';
+
+export const listPayments = async (modBody) => {
+  return handleListPayments(modBody);
+};
+
+export const createTransaction = async (modBody) => {
+  return handleCreateTransaction(modBody);
+};
+// # sourceMappingURL=pagarme-v5.js.map

package/packages/apps/pagarme-v5/lib/pagarme-v5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagarme-v5.js","sourceRoot":"","sources":["../src/pagarme-v5.ts"],"names":[],"mappings":"AAAA,OAAO,kCAAkC,CAAC;AAE1C,OAAO,kBAAkB,MAAM,uCAAuC,CAAC;AACvE,OAAO,uBAAuB,MAAM,4CAA4C,CAAC;AAEjF,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAAE,OAAsB,EAAE,EAAE;IAC3D,OAAO,kBAAkB,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,EAAE,OAAsB,EAAE,EAAE;IAChE,OAAO,uBAAuB,CAAC,OAAO,CAAC,CAAC;AAC1C,CAAC,CAAC"}

package/packages/apps/pagarme-v5/lib-mjs/create-pagarme5-transaction.mjs

@@ -0,0 +1,208 @@
+import logger from 'firebase-functions/logger';
+import config from '@cloudcommerce/firebase/lib/config';
+import { getFirestore } from 'firebase-admin/firestore';
+import { createSubscription, createPayment } from './functions-lib/pagarme/payment-subscription.mjs';
+import { getPlanInTransction } from './functions-lib/pagarme/handle-plans.mjs';
+import { parserInvoiceStatusToEcom, parseAddress } from './functions-lib/pagarme/parses-utils.mjs';
+import axios from './functions-lib/pagarme/create-axios.mjs';
+
+export default async (appData) => {
+  const colletionFirebase = getFirestore().collection('pagarmeV5Subscriptions');
+
+  const { params, application } = appData;
+
+  const configApp = { ...application.data, ...application.hidden_data };
+
+  if (!process.env.PAGARMEV5_API_TOKEN) {
+    const pagarmeApiToken = configApp.pagarme_api_token;
+    if (pagarmeApiToken && typeof pagarmeApiToken === 'string') {
+      process.env.PAGARMEV5_API_TOKEN = pagarmeApiToken;
+    } else {
+      logger.warn('Missing PAGARMEV5 API TOKEN');
+    }
+  }
+
+  const pagarmeAxios = axios(process.env.PAGARMEV5_API_TOKEN);
+  const { storeId } = config.get();
+
+  const orderId = params.order_id;
+
+  const { amount, to, buyer } = params;
+  logger.log(`[PagarMe V5] Transaction #${orderId}`);
+  logger.log(`[PagarMe V5] Type transaction ${params.type}`);
+
+  const paymentMethod = params.payment_method.code;
+
+  const transaction = {
+    amount: amount.total,
+  };
+
+  const isRecurrence = params.type === 'recurrence';
+  let subscriptionPagarmeId;
+  let address;
+
+  if (to && to.street) {
+    address = parseAddress(to);
+  } else if (params.billing_address) {
+    address = parseAddress(params.billing_address);
+  }
+
+  let redirectToPayment = false;
+  try {
+    const pagarMeCustomer = {
+      name: buyer.fullname,
+      type: buyer.registry_type === 'j' ? 'company' : 'individual',
+      email: buyer.email,
+      code: buyer.customer_id,
+      document: buyer.doc_number,
+      document_type: buyer.registry_type === 'j' ? 'cnpj' : 'cpf',
+      address,
+      phones: {
+        [`${buyer.phone.type === 'personal' ? 'mobile_phone' : 'home_phone'}`]: {
+          country_code: `${(buyer.phone.country_code || 55)}`,
+          area_code: (buyer.phone.number).substring(0, 2),
+          number: (buyer.phone.number).substring(2),
+        },
+      },
+    };
+    const birthDate = buyer.birth_date;
+    if (birthDate && birthDate.year && birthDate.day) {
+      pagarMeCustomer.birthday = `${birthDate.year}-`
+        + `${birthDate.month.toString().padStart(2, '0')}-`
+        + birthDate.day.toString().padStart(2, '0');
+    }
+
+    if (isRecurrence) {
+      const methodConfigName = params.payment_method.code === 'credit_card' ? configApp.credit_card.label : configApp.banking_billet.label;
+      let labelPaymentGateway = params.payment_method.name.replace('- Pagar.me', '');
+      labelPaymentGateway = labelPaymentGateway.replace(methodConfigName, '');
+
+      const plan = getPlanInTransction(labelPaymentGateway, configApp.recurrence);
+      const { data: subcription } = await createSubscription(
+        params,
+        configApp,
+        storeId,
+        plan,
+        pagarMeCustomer,
+      );
+      logger.log(`[PagarMe V5] Response: ${JSON.stringify(subcription)}`);
+      subscriptionPagarmeId = subcription.id;
+      // /invoices
+      const { data: { data: invoices } } = await pagarmeAxios.get(`/invoices?subscription_id=${subscriptionPagarmeId}`);
+      logger.log(`[PagarMe V5] Invoices: ${JSON.stringify(invoices)}`);
+
+      const { data: charge } = await pagarmeAxios.get(`/charges/${invoices[0].charge.id}`);
+
+      logger.log(`[PagarMe V5] Charge: ${JSON.stringify(charge)}`);
+      const transactionPagarme = charge.last_transaction;
+
+      transaction.status = {
+        updated_at: invoices[0].created_at || new Date().toISOString(),
+        current: parserInvoiceStatusToEcom(invoices[0].status),
+      };
+
+      transaction.intermediator = {
+        transaction_id: invoices[0].id,
+        transaction_code: `${transactionPagarme.acquirer_auth_code || ''}`,
+        transaction_reference: `${transactionPagarme.acquirer_tid || ''}`,
+      };
+
+      if (paymentMethod === 'banking_billet') {
+        transaction.banking_billet = {
+          // code: charge.last_transaction.barcode,
+          valid_thrud: charge.last_transaction.due_at,
+          link: charge.last_transaction.pdf,
+        };
+        transaction.payment_link = charge.last_transaction.url;
+        redirectToPayment = true;
+      }
+      // console.log('>> transaction ', JSON.stringify(transaction))
+      await colletionFirebase.doc(orderId)
+        .set({
+          status: subcription.status,
+          orderNumber: params.order_number,
+          created_at: new Date().toISOString(),
+          plan,
+          subscriptionPagarmeId,
+          invoicePagarmeId: invoices[0].id,
+          changePagarmeId: charge.id,
+          items: subcription.items,
+          amount,
+        })
+        .catch(logger.error);
+
+      // logger.log('[PagarMe V5] Save Firebase');
+    } else {
+      // type payment
+      const { data: payment } = await createPayment(params, configApp, pagarMeCustomer);
+      logger.log(`[PagarMe V5] Response: ${JSON.stringify(payment)}`);
+      const [charge] = payment.charges;
+
+      const transactionPagarme = charge.last_transaction;
+
+      transaction.status = {
+        updated_at: charge.created_at || new Date().toISOString(),
+        current: parserInvoiceStatusToEcom(charge.status),
+      };
+
+      transaction.intermediator = {
+        transaction_id: payment.id,
+        transaction_code: `${transactionPagarme.acquirer_auth_code || ''}`,
+        transaction_reference: `${transactionPagarme.acquirer_tid || ''}`,
+      };
+
+      if (paymentMethod === 'account_deposit') {
+        let notes = '<div style="display:block;margin:0 auto"> ';
+        notes += `<img src="${transactionPagarme.qr_code_url}" style="display:block;margin:0 auto"> `;
+        notes += '</div>';
+        transaction.notes = notes;
+        if (transactionPagarme.qr_code) {
+          transaction.intermediator.transaction_code = transactionPagarme.qr_code;
+        }
+        if (transactionPagarme.expires_at) {
+          transaction.account_deposit = {
+            valid_thru: transactionPagarme.expires_at,
+          };
+        }
+      } else if (paymentMethod === 'banking_billet') {
+        transaction.banking_billet = {
+          // code: charge.last_transaction.barcode,
+          valid_thrud: charge.last_transaction.due_at,
+          link: charge.last_transaction.pdf,
+        };
+        transaction.payment_link = charge.last_transaction.url;
+        redirectToPayment = true;
+      }
+    }
+
+    return {
+      redirect_to_payment: redirectToPayment,
+      transaction,
+    };
+  } catch (error) {
+    logger.error(error);
+    // try to debug request error
+    const errCode = isRecurrence ? 'PAGARMEV5_SUBSCRIPTION_ERR' : 'PAGARMEV5_TRANSACTION_ERR';
+    let { message } = error;
+    const err = new Error(`${errCode}- ${orderId} => ${message}`);
+    if (error.response) {
+      const { status, data } = error.response;
+      if (status !== 401 && status !== 403) {
+        // err.payment = JSON.stringify(pagarmeTransaction)
+        err.status = status;
+        if (typeof data === 'object' && data) {
+          err.response = JSON.stringify(data);
+        } else {
+          err.response = data;
+        }
+      } else if (data && Array.isArray(data.errors) && data.errors[0] && data.errors[0].message) {
+        message = data.errors[0].message;
+      }
+    }
+    // logger.error(err);
+    return {
+      error: errCode,
+      message,
+    };
+  }
+};

package/packages/apps/pagarme-v5/lib-mjs/events-to-pagarme5.mjs

@@ -0,0 +1,209 @@
+import api from '@cloudcommerce/api';
+import logger from 'firebase-functions/logger';
+// import config from '@cloudcommerce/firebase/lib/config';
+import { getFirestore } from 'firebase-admin/firestore';
+import ecomUtils from '@ecomplus/utils';
+import axios from './functions-lib/pagarme/create-axios.mjs';
+import { getOrderWithQueryString } from './functions-lib/api-utils.mjs';
+import { getDocFirestore } from './functions-lib/firestore-utils.mjs';
+
+const colletionFirebase = getFirestore().collection('pagarmeV5Subscriptions');
+
+const eventOrderCancelled = async (
+  apiDoc,
+  pagarmeAxios,
+) => {
+  const order = apiDoc;
+  if (order?.transactions[0]?.type === 'recurrence') {
+    const { data: { data: subcriptions } } = await pagarmeAxios.get(`/subscriptions?code=${order._id}`);
+    if (subcriptions && subcriptions[0].status !== 'canceled') {
+      try {
+        logger.log(`> (App PagarMe V5): Try cancel subscription: #${order._id}`);
+        await pagarmeAxios.delete(`/subscriptions/${subcriptions[0].id}`);
+        logger.log('> (App PagarMe V5):  Successfully canceled');
+        await colletionFirebase.doc(order._id)
+          .set({
+            status: 'cancelled',
+            updatedAt: new Date().toISOString(),
+          }, { merge: true })
+          .catch(logger.error);
+
+        logger.log('>> SUCESSS');
+        return null;
+      } catch (err) {
+        logger.error('> (App PagarMe V5): Error when canceling in Pagar.Me, return the status');
+        await api.patch(order._id, { status: 'open' })
+          .catch(logger.error);
+
+        return null;
+      }
+    } else {
+      logger.log('> (App PagarMe V5): Subscription already canceled or does not exist');
+      return null;
+    }
+  }
+  // edit items order order Original
+  return null;
+};
+
+const eventProducts = async (
+  apiDoc,
+  pagarmeAxios,
+) => {
+  // console.log('> Edit product ', resourceId, 's: ', storeId);
+  const product = apiDoc;
+
+  let query = 'status!=cancelled&transactions.type=recurrence';
+  query += '&transactions.app.intermediator.code=pagarme';
+  query += `&items.product_id=${product._id}`;
+
+  const result = await getOrderWithQueryString(query);
+
+  if (result && result.length) {
+    let i = 0;
+    while (i < result.length) {
+      const updateItemPagarme = [];
+      // eslint-disable-next-line no-await-in-loop
+      const order = (await api.get(`orders/${result[i]._id}`)).data;
+      // eslint-disable-next-line no-await-in-loop
+      const docSubscription = await getDocFirestore(colletionFirebase, result[i]._id);
+      logger.log('> (App PagarMe v5): Order ', JSON.stringify(order), ' ', JSON.stringify(docSubscription));
+      if (order && docSubscription) {
+        const itemsUpdate = [];
+        order.items.forEach((orderItem) => {
+          if (orderItem.product_id === product._id) {
+            if (orderItem.variation_id) {
+              const variation = product.variations
+                .find((itemFind) => itemFind.sku === orderItem.sku);
+
+              let quantity = orderItem.quantity;
+              if (variation && variation.quantity < orderItem.quantity) {
+                quantity = variation.quantity;
+              } else if (!variation) {
+                quantity = 0;
+              }
+              const newItem = {
+                sku: variation.sku,
+                price: ecomUtils.price({ ...product, ...variation }),
+                quantity,
+              };
+              if ((orderItem.final_price && orderItem.final_price !== newItem.price)
+                || orderItem.price !== newItem.price || orderItem.quantity !== newItem.quantity) {
+                itemsUpdate.push(newItem);
+              }
+            } else {
+              const newItem = {
+                sku: product.sku,
+                price: ecomUtils.price(product),
+                quantity: product.quantity < orderItem.quantity
+                  ? product.quantity : orderItem.quantity,
+              };
+              if ((orderItem.final_price && orderItem.final_price !== newItem.price)
+                || orderItem.price !== newItem.price || orderItem.quantity !== newItem.quantity) {
+                itemsUpdate.push(newItem);
+              }
+            }
+          }
+        });
+
+        if (itemsUpdate.length) {
+          docSubscription?.items?.forEach((itemPagarme) => {
+            const itemToEdit = itemsUpdate.find((itemFind) => itemPagarme.id === `pi_${itemFind.sku}`);
+            if (itemToEdit && !itemPagarme.cycles) {
+              itemPagarme.quantity = itemToEdit.quantity;
+              itemPagarme.pricing_scheme.price = Math.floor((itemToEdit.price) * 100);
+              updateItemPagarme.push({
+                subscription_id: docSubscription.subscriptionPagarmeId,
+                item: itemPagarme,
+              });
+            }
+          });
+        }
+      }
+      // order not found or error
+      if (updateItemPagarme.length) {
+        logger.log('> (App PagarMe V5): Try update item in Pagar.Me');
+        try {
+          // eslint-disable-next-line no-await-in-loop
+          await Promise.all(updateItemPagarme.map((itemPagarme) => {
+            return pagarmeAxios.put(
+              `/subscriptions/${itemPagarme.subscription_id}/items/${itemPagarme.item.id}`,
+              {
+                ...itemPagarme.item,
+              },
+            );
+          }));
+        } catch (err) {
+          logger.error(err);
+          /* When creating a new order, check the items saved in Pagar.Me
+            with the original order items
+
+           No need to save to firestore
+          */
+        }
+      }
+      i += 1;
+    }
+    logger.log('>> SUCESSS');
+    return null;
+  }
+  logger.log('>> Orders not found ');
+  return null;
+};
+
+const handleApiEvent = async ({
+  evName,
+  apiEvent,
+  apiDoc,
+  app,
+}) => {
+  const resourceId = apiEvent.resource_id;
+  logger.info('>> ', resourceId, ' - Action: ', apiEvent.action);
+  const key = `${evName}_${resourceId}`;
+  const configApp = { ...app.data, ...app.hidden_data };
+  if (
+    Array.isArray(configApp.ignore_events)
+    && configApp.ignore_events.includes(evName)
+  ) {
+    logger.info('>> ', key, ' - Ignored event');
+    return null;
+  }
+  logger.info(`> Webhook ${resourceId} [${evName}] => ${apiDoc}`);
+
+  if (!process.env.PAGARMEV5_API_TOKEN) {
+    const pagarmeApiToken = configApp.pagarme_api_token;
+    if (pagarmeApiToken && typeof pagarmeApiToken === 'string') {
+      process.env.PAGARMEV5_API_TOKEN = pagarmeApiToken;
+    } else {
+      logger.warn('Missing PAGARMEV5 API TOKEN');
+      return null;
+    }
+  }
+
+  try {
+    const pagarmeAxios = axios(process.env.PAGARMEV5_API_TOKEN);
+
+    if (evName === 'orders-cancelled') {
+      return eventOrderCancelled(apiDoc, pagarmeAxios);
+    }
+
+    if (evName.startsWith('products-') && evName !== 'products-new') {
+      return eventProducts(apiDoc, pagarmeAxios);
+    }
+
+    return null;
+  } catch (error) {
+    const statusCode = error.response?.status;
+    if (statusCode === 404) {
+      logger.warn('> (App PagarMe V5): Subscription not found in PagarMe');
+      return null;
+    }
+    if (statusCode === 401 || statusCode === 403) {
+      logger.warn('> (App PagarMe V5): Unauthorized subscription deletion request');
+      return null;
+    }
+    throw error;
+  }
+};
+
+export default handleApiEvent;

package/packages/apps/pagarme-v5/lib-mjs/functions-lib/api-utils.mjs

@@ -0,0 +1,220 @@
+import ecomUtils from '@ecomplus/utils';
+import api from '@cloudcommerce/api';
+
+const getOrderById = async (orderId) => {
+  const { data } = await api.get(`orders/${orderId}`);
+  return data;
+};
+
+const addPaymentHistory = async (orderId, body) => {
+  return api.post(`orders/${orderId}/payments_history`, body);
+};
+
+const updateTransaction = (orderId, body, transactionId) => {
+  const urlTransaction = transactionId ? `/${transactionId}` : '';
+  const method = transactionId ? 'PATCH' : 'POST';
+
+  return api[method](`orders/${orderId}/transactions${urlTransaction}`, body);
+};
+
+const getOrderIntermediatorTransactionId = async (invoiceId) => {
+  let queryString = `?transactions.intermediator.transaction_id=${invoiceId}`;
+  queryString += '&fields=transactions,financial_status.current,status';
+  const data = await api.get(`orders${queryString}`);
+
+  return data?.result.length ? data?.result[0] : null;
+};
+
+const checkItemsAndRecalculeteOrder = (amount, items, plan, itemsPagarme) => {
+  let subtotal = 0;
+  let item;
+  let i = 0;
+  while (i < items.length) {
+    item = items[i];
+
+    if (item.flags && (item.flags.includes('freebie') || item.flags.includes('discount-set-free'))) {
+      items.splice(i, 1);
+    } else {
+      // eslint-disable-next-line no-loop-func
+      const itemFound = itemsPagarme.find((itemFind) => itemFind.id === `pi_${item.sku}`);
+
+      if (itemFound) {
+        item.quantity = itemFound.quantity;
+        if (item.final_price) {
+          item.final_price = (itemFound.pricing_scheme.price / 100);
+        }
+        item.price = (itemFound.pricing_scheme.price / 100);
+        subtotal += item.quantity * (item.final_price || item.price);
+        i += 1;
+      } else {
+        items.splice(i, 1);
+      }
+    }
+  }
+
+  if (subtotal > 0) {
+    amount.subtotal = subtotal;
+    amount.total = amount.subtotal + (amount.tax || 0)
+      + (amount.freight || 0) + (amount.extra || 0);
+
+    let planDiscount;
+    if (plan && plan.discount) {
+      if (plan.discount.type === 'percentage') {
+        planDiscount = amount[plan.discount.apply_at];
+        planDiscount *= ((plan.discount.value) / 100);
+      }
+    }
+    // if the plan doesn't exist, because it's subscription before the update
+    amount.discount = plan ? ((plan.discount && plan.discount.type !== 'percentage' ? plan.discount.value : planDiscount) || 0) : (amount.discount || 0);
+
+    amount.total -= amount.discount;
+    amount.total = amount.total > 0 ? amount.total : 0;
+
+    return amount.total > 0 ? Math.floor((amount.total).toFixed(2) * 1000) / 10 : 0;
+  }
+
+  return 0;
+};
+
+const createNewOrderBasedOld = (oldOrder, plan, status, charge, subscriptionPagarme) => {
+  const {
+    buyers, items, domain, amount,
+  } = oldOrder;
+  const channelType = oldOrder.channel_type;
+  const shippingLines = oldOrder.shipping_lines;
+  const shippingMethodLabel = oldOrder.shipping_method_label;
+  const paymentMethodLabel = oldOrder.payment_method_label;
+  const originalTransaction = oldOrder.transactions[0];
+
+  const portion = charge.code?.replace(`${oldOrder._id}-`, '');
+  const itemsPagarme = subscriptionPagarme.items;
+
+  checkItemsAndRecalculeteOrder(amount, items, plan, itemsPagarme);
+  if (amount.balance) {
+    delete amount.balance;
+  }
+
+  items.forEach((item) => {
+    if (item.stock_status && item.stock_status !== 'unmanaged') {
+      item.stock_status = 'pending';
+    }
+  });
+  const transactionPagarme = charge.last_transaction;
+
+  const transactions = [
+    {
+      amount: amount.total,
+      status: {
+        updated_at: transactionPagarme.updated_at || new Date().toISOString(),
+        current: status,
+      },
+      intermediator: {
+        transaction_id: `${charge.invoice.id}`,
+        transaction_code: `${transactionPagarme.acquirer_auth_code || ''}`,
+        transaction_reference: `${transactionPagarme.acquirer_tid || ''}`,
+      },
+      payment_method: originalTransaction.payment_method,
+      app: originalTransaction.app,
+      _id: ecomUtils.randomObjectId(),
+      notes: `Parcela #${portion} referente à ${plan?.label || 'Assinatura'}`,
+      custom_fields: originalTransaction.custom_fields,
+    },
+  ];
+
+  transactions[0].payment_link = transactionPagarme.url;
+
+  const financialStatus = {
+    updated_at: transactionPagarme.updated_at || new Date().toISOString(),
+    current: status,
+  };
+
+  let notes = `Parcela #${portion} desconto de ${plan.discount.type === 'percentage' ? '' : 'R$'}`;
+  notes += ` ${plan.discount.value} ${plan.discount.type === 'percentage' ? '%' : ''}`;
+  notes += ` sobre ${plan.discount.apply_at}`;
+
+  const body = {
+    opened_at: new Date().toISOString(),
+    items,
+    shipping_lines: shippingLines,
+    buyers,
+    channel_type: channelType,
+    domain,
+    amount,
+    shipping_method_label: shippingMethodLabel,
+    payment_method_label: paymentMethodLabel,
+    transactions,
+    financial_status: financialStatus,
+    subscription_order: {
+      _id: oldOrder._id,
+      number: oldOrder.number,
+    },
+    notes,
+    staff_notes: `Valor cobrado no Pagar.Me R$${(charge.amount) / 100}`,
+  };
+  return api.post('orders', body);
+};
+
+// const updateOrder = async (orderId, body) => {
+//   return api.patch(`orders/${orderId}`, body);
+// };
+
+const getOrderWithQueryString = async (query) => {
+  const { data } = await api.get(`orders?${query}`);
+
+  return data?.result.length ? data?.result : null;
+};
+
+const getProductById = async (productId) => {
+  const { data } = await api.get(`products/${productId}`);
+  return data;
+};
+
+const checkItemCategory = async (categoryIds, itemsPagarme, itemsApi) => {
+  let i = 0;
+
+  const itemsIdPagarmeDelete = [];
+  while (i < itemsPagarme.length) {
+    const itemPagarme = itemsPagarme[i];
+    // Obs.: freight is one item, initially do not remove freight
+    const isItemFreigth = itemPagarme?.id?.startsWith('pi_freight_');
+    const itemFound = itemsApi.find((itemFind) => itemPagarme.id === `pi_${itemFind.sku}`);
+    const itemFoundIndex = itemsApi.indexOf(itemFound);
+
+    if (itemFound && !isItemFreigth) {
+      // eslint-disable-next-line no-await-in-loop
+      const product = await getProductById(itemFound.product_id);
+      if (product.categories) {
+        let canSign = false;
+        product.categories.forEach((category) => {
+          if (categoryIds.includes(category._id)) {
+            canSign = true;
+          }
+        });
+
+        if (!canSign) {
+          itemsIdPagarmeDelete.push(itemPagarme.id);
+          itemsApi.splice(itemFoundIndex, 1);
+        }
+      } else {
+        itemsIdPagarmeDelete.push(itemPagarme.id);
+        itemsApi.splice(itemFoundIndex, 1);
+      }
+    } else if (!isItemFreigth) {
+      itemsIdPagarmeDelete.push(itemPagarme.id);
+    }
+    i += 1;
+  }
+
+  return itemsIdPagarmeDelete;
+};
+
+export {
+  getOrderById,
+  addPaymentHistory,
+  updateTransaction,
+  getOrderIntermediatorTransactionId,
+  createNewOrderBasedOld,
+  getOrderWithQueryString,
+  getProductById,
+  checkItemCategory,
+};

package/packages/apps/pagarme-v5/lib-mjs/functions-lib/firestore-utils.mjs

@@ -0,0 +1,24 @@
+import logger from 'firebase-functions/logger';
+
+const getDocFirestore = async (collection, documentId) => {
+  const documentSnapshot = await collection.doc(documentId).get();
+  let data;
+  if (documentSnapshot) {
+    data = documentSnapshot.data();
+  }
+  return data;
+};
+
+const updateDocFirestore = async (collection, documentId, body) => {
+  const updatedAt = new Date().toISOString();
+  body.updatedAt = updatedAt;
+
+  await collection.doc(documentId)
+    .set(body, { merge: true })
+    .catch(logger.error);
+};
+
+export {
+  getDocFirestore,
+  updateDocFirestore,
+};

package/packages/apps/pagarme-v5/lib-mjs/functions-lib/pagarme/create-axios.mjs

@@ -0,0 +1,12 @@
+import axios from 'axios';
+
+export default (apiSecretKey) => {
+  return axios.create({
+    baseURL: 'https://api.pagar.me/core/v5',
+    headers: {
+      accept: 'application/json',
+      'content-type': 'application/json',
+      Authorization: 'Basic ' + Buffer.from(`${apiSecretKey}:`).toString('base64'),
+    },
+  });
+};