connector-openpay-mx/src/resources/index.js

Package that allows us to connect to OpenPay Mexico and make use of the following resources.

const Openpay = require('openpay');
const validation = require('./validation');
const { defaultWebhookConfig } = require('../configuration');

const setConnection = account => {
    let connection = [];
    const { error, response } = validation.isValidMerchant(account);

   if (error === null) {
       connection = new Openpay(account.merchant.id, account.merchant.private_key, response.openpay_set_production);
   }

    return { error, response, connection };
};

const getMerchant = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.merchant.get(function (error, customerId = connection.merchantId) {
            resolve({ error, response: customerId });
        })
    ));
};

const createCustomer = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.create(parameters.customer, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const updateCustomer = async parameters => {
    const { customer = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.update(parameters.customerId, customer, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getCustomer = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.get(parameters.customerId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getCustomers = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.list(parameters.searchParams, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const deleteCustomer = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.delete(parameters.customerId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const createBankAccount = async parameters => {
    const { bankAccount = {} } = parameters;
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.bankaccounts.create(parameters.customerId, bankAccount, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const deleteBankAccount = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.bankaccounts.delete(parameters.customerId, parameters.bankaccountId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getBankAccount = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.bankaccounts.get(parameters.customerId, parameters.bankaccountId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getBankAccounts = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.bankaccounts.list(parameters.customerId, (error, response) => (
            resolve({ error, response })
        ))
    ));
}

const createCard = async parameters => {
    const { cardRequest = {} } = parameters;
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.cards.create(parameters.customerId, cardRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const deleteCard = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.cards.delete(parameters.customerId, parameters.cardId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getCard = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.cards.get(parameters.customerId, parameters.cardId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getCards = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.cards.list(parameters.customerId, parameters.searchParams, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const createWebHook = async parameters => {
    const { webhook } = parameters;
    const { error, response, connection } = setConnection(parameters);

    if (webhook.event_types.length === 0) {
        webhook.event_types = defaultWebhookConfig.event_types;
    }

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.webhooks.create(webhook, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const deleteWebHook = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.webhooks.delete(parameters.webhookId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getWebHook = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.webhooks.get(parameters.webhookId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getWebHooks = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.webhooks.list((error, response) => (
            resolve({ error, response })
        ))
    ));
};

const createBankCharge = async parameters => {
    const { bankChargeRequest = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.charges.create(parameters.customerId, bankChargeRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const createStoreCharge = async parameters => {
    const { storeChargeRequest = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.charges.create(parameters.customerId, storeChargeRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const createCardCharge = async parameters => {
    const { chargeRequest = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.charges.create(parameters.customerId, chargeRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const canConfirmCharge = async parameters => {
    const { captureRequest = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.charges.capture(parameters.customerId, parameters.transactionId, captureRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getCharge = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.charges.get(parameters.customerId, parameters.transactionId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const createPayment = async parameters => {
    const { payoutRequest = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.payouts.create(parameters.customerId, payoutRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getPayment = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.payouts.get(parameters.customerId, parameters.transactionId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const createPlan = async parameters => {
    const { planRequest = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.plans.create(planRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getPlan = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.plans.get(parameters.planId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getPlans = async parameters => {
    const { searchParams = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.plans.list(searchParams,(error, response) => (
            resolve({ error, response })
        ))
    ));
};

const createSubscription = async parameters => {
    const { subscriptionRequest = {} } = parameters
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.subscriptions.create(parameters.customerId, subscriptionRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const updateSubscription = async parameters => {
    const { subscriptionRequest = {} } = parameters

    const { error, response, connection } = setConnection(parameters);
    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.subscriptions.update(parameters.customerId, parameters.subscriptionId, subscriptionRequest, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const deleteSubscription = async parameters => {
    const { error, response, connection } = setConnection(parameters);

    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.subscriptions.delete(parameters.customerId, parameters.subscriptionId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getSubscription = async parameters => {
    const { error, response, connection } = setConnection(parameters);
    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.subscriptions.get(parameters.customerId, parameters.subscriptionId, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

const getSubscriptions = async parameters => {
    const { searchParams = {} } = parameters;
    const { error, response, connection } = setConnection(parameters);
    if (response === null) return { error: error.details[0], response };
    return new Promise((resolve) => (
        connection.customers.subscriptions.list(parameters.customerId, searchParams, (error, response) => (
            resolve({ error, response })
        ))
    ));
};

module.exports = {
    getMerchant,
    createCustomer,
    updateCustomer,
    getCustomer,
    getCustomers,
    deleteCustomer,
    createBankAccount,
    deleteBankAccount,
    getBankAccount,
    getBankAccounts,
    createCard,
    deleteCard,
    getCard,
    getCards,
    createWebHook,
    deleteWebHook,
    getWebHook,
    getWebHooks,
    createBankCharge,
    createStoreCharge,
    createCardCharge,
    canConfirmCharge,
    getCharge,
    createPayment,
    getPayment,
    createPlan,
    getPlan,
    getPlans,
    createSubscription,
    updateSubscription,
    deleteSubscription,
    getSubscription,
    getSubscriptions,
};