@infrab4a/connect-nestjs 3.0.0-alpha.0 → 3.0.0-alpha.1

package/index.cjs.js

@@ -0,0 +1,1334 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var elasticsearch = require('@elastic/elasticsearch');
+var connect = require('@infrab4a/connect');
+var common = require('@nestjs/common');
+var firestore = require('firebase-admin/firestore');
+var pagarme = require('pagarme');
+var discoveryengine = require('@google-cloud/discoveryengine');
+var v1beta = require('@google-cloud/discoveryengine/build/src/v1beta');
+var nestjsFirebase = require('nestjs-firebase');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var pagarme__default = /*#__PURE__*/_interopDefaultLegacy(pagarme);
+
+const ES_CONFIG = 'ES_CONFIG';
+
+const HASURA_OPTIONS = 'HASURA_OPTIONS';
+
+const FIREBASE_STORAGE = 'FIREBASE_STORAGE';
+
+const VERTEX_CONFIG = 'VERTEX_CONFIG';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.NativeElasticSearchAdapter = class NativeElasticSearchAdapter {
+    constructor(config) {
+        this.logger = connect.DebugHelper.from(this);
+        try {
+            this.client = !connect.isEmpty(config.cloud.id) && !connect.isEmpty(config.auth.apiKey) && new elasticsearch.Client(config);
+        }
+        catch (error) {
+            this.logger.error({ req: config, res: error });
+            throw error;
+        }
+    }
+    async get(index, id) {
+        const logger = this.logger.with('get');
+        const req = { index, id };
+        try {
+            const data = await this.client.get({ index, id });
+            logger.log({ req, res: data });
+            return data._source;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : `${index}/${id} not found`;
+            logger.log({ req, res: error });
+            throw new connect.NotFoundError(message);
+        }
+    }
+    async query(index, query) {
+        const logger = this.logger.with('query');
+        const params = {
+            index,
+            query,
+        };
+        try {
+            const result = await this.client.search(params);
+            const res = {
+                total: result.hits.total,
+                hits: result.hits.hits,
+            };
+            logger.log({ req: params, res });
+            return res;
+        }
+        catch (error) {
+            logger.error({ req: params, res: error });
+            throw error;
+        }
+    }
+    async save(index, data) {
+        const logger = this.logger.with('save');
+        const req = {
+            index,
+            id: data.identifiersFields.length > 1
+                ? JSON.stringify(data.identifier)
+                : Object.values(data.identifier).shift().toString(),
+            document: data.toPlain(),
+        };
+        try {
+            const res = await this.client.index(req);
+            logger.log({ req, res });
+        }
+        catch (error) {
+            logger.error({ req, res: error });
+            throw error;
+        }
+    }
+    async update(index, id, data) {
+        const logger = this.logger.with('update');
+        const req = {
+            index,
+            id,
+            doc: data,
+        };
+        try {
+            await this.client.update(req);
+            logger.log({ req, res: undefined });
+        }
+        catch (error) {
+            logger.error({ req, res: error });
+            throw error;
+        }
+    }
+    async delete(index, id) {
+        const logger = this.logger.with('delete');
+        const req = {
+            index,
+            id,
+        };
+        try {
+            await this.client.delete(req);
+            logger.log({ req, res: undefined });
+        }
+        catch (error) {
+            logger.error({ req, res: error });
+            throw error;
+        }
+    }
+};
+exports.NativeElasticSearchAdapter = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(ES_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], exports.NativeElasticSearchAdapter);
+
+class ConnectBaseDocumentSnapshot {
+    constructor(connectDocumentSnapshot) {
+        this.connectDocumentSnapshot = connectDocumentSnapshot;
+        this.id = connectDocumentSnapshot.id;
+    }
+    isNotEmpty() {
+        return this.connectDocumentSnapshot.exists;
+    }
+    data(_options) {
+        return this.connectDocumentSnapshot.data();
+    }
+    get(fieldPath) {
+        return this.connectDocumentSnapshot.get(fieldPath);
+    }
+}
+
+class ConnectDocumentService {
+    constructor(path, firestore) {
+        this.path = path;
+        this.firestore = firestore;
+        this.reference = this.firestore.doc(this.path).withConverter({
+            toFirestore: (data) => data,
+            fromFirestore: (snapshot) => {
+                return Object.assign({ id: snapshot.id }, snapshot.data());
+            },
+        });
+    }
+    async get() {
+        return new ConnectBaseDocumentSnapshot(await this.reference.get());
+    }
+    getId() {
+        return this.reference.id;
+    }
+    async save(data) {
+        if (this.reference)
+            this.reference.update(data);
+        else
+            await this.reference.set(data);
+        return this;
+    }
+    async delete() {
+        await this.reference.delete();
+    }
+    withConverter(params) {
+        this.reference = this.reference.withConverter({
+            toFirestore: (data) => params.toFirestore(data),
+            fromFirestore: (snapshot, options) => params.fromFirestore(new ConnectBaseDocumentSnapshot(snapshot), options),
+        });
+        return this;
+    }
+}
+
+class ConnectCollectionService {
+    constructor(path, firestore) {
+        this.firestore = firestore;
+        this.reference = firestore.collection(path).withConverter({
+            toFirestore: (data) => data,
+            fromFirestore: (snapshot) => {
+                return Object.assign({ id: snapshot.id }, snapshot.data());
+            },
+        });
+    }
+    async add(data, id) {
+        const newDoc = await this.save(data, id);
+        return new ConnectDocumentService(newDoc.path, this.firestore).withConverter(this.converter);
+    }
+    async getDocs() {
+        if (this.startingAt)
+            this.limitBy += this.startingAt;
+        let query = this.query ? this.query : this.reference;
+        query = this.orderBy ? query.orderBy(this.orderBy.fieldPath, this.orderBy.directionStr) : query;
+        query = this.limitBy ? query.limit(this.limitBy) : query;
+        return query.get().then((docs) => {
+            const docsPaginated = this.startingAt ? docs.docs.slice(this.startingAt, this.limitBy) : docs.docs;
+            return {
+                empty: Boolean(docsPaginated.length),
+                size: docsPaginated.length,
+                docs: docsPaginated.map((doc) => new ConnectBaseDocumentSnapshot(doc)),
+            };
+        });
+    }
+    getDoc(id) {
+        return new ConnectDocumentService(`${this.reference.path}/${id}`, this.firestore).withConverter(this.converter);
+    }
+    where(fieldPath, opStr, value) {
+        this.query = this.query ? this.query.where(fieldPath, opStr, value) : this.reference.where(fieldPath, opStr, value);
+        return this;
+    }
+    order(attribute, order) {
+        this.orderBy = { fieldPath: attribute, directionStr: order };
+        return this;
+    }
+    limit(quantity) {
+        this.limitBy = quantity;
+        return this;
+    }
+    offset(offsetBy) {
+        this.offsetBy = offsetBy;
+        return this;
+    }
+    fromStartAt(startingAt) {
+        this.startingAt = startingAt;
+        return this;
+    }
+    fromStartAfter(startingAt) {
+        this.startingAfter = startingAt;
+        return this;
+    }
+    withConverter(params) {
+        this.converter = params;
+        this.reference = this.reference.withConverter({
+            toFirestore: (data) => params.toFirestore(data),
+            fromFirestore: (snapshot, options) => params.fromFirestore(new ConnectBaseDocumentSnapshot(snapshot), options),
+        });
+        return this;
+    }
+    async save(data, id) {
+        if (connect.isEmpty(id))
+            return this.reference.add(data);
+        const docRef = this.reference.doc(id);
+        await docRef.set(data);
+        return docRef;
+    }
+}
+
+exports.ConnectFirestoreService = class ConnectFirestoreService {
+    constructor(firestore) {
+        this.firestore = firestore;
+    }
+    getCollection(path) {
+        return new ConnectCollectionService(path, this.firestore);
+    }
+    getDocument(path) {
+        return new ConnectDocumentService(path, this.firestore);
+    }
+};
+exports.ConnectFirestoreService = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [firestore.Firestore])
+], exports.ConnectFirestoreService);
+
+class PagarmeBankSlipAPIAdapter {
+    constructor(credentials, paymentRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async pay(checkout) {
+        try {
+            const client = await pagarme__default["default"].client.connect({ api_key: this.credentials.API_KEY });
+            const payload = this.createBoletoPayment(checkout);
+            const result = await client.transactions.create(payload);
+            console.warn('[PAGARME BOLETO DATA TO SEND]', payload);
+            console.warn('result PagarmeBankSlipAPIAdapter', JSON.stringify(result));
+            if (result.status !== connect.PagarmePaymentStatus['Em processamento']) {
+                return Promise.reject(new connect.PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', {
+                    checkoutId: checkout.id,
+                    userEmail: checkout.user.email,
+                    info: result,
+                }));
+            }
+            const payment = await this.paymentRepository.create({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                userId: checkout.user.id,
+                checkoutId: checkout.id,
+                totalPrice: checkout.totalPrice,
+                paymentProvider: 'pagarMe',
+                transaction: result,
+            });
+            return payment;
+        }
+        catch (error) {
+            console.error('Error PagarmeBankSlipAPIAdapter', JSON.stringify(error));
+            throw new connect.PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error,
+            });
+        }
+    }
+    async getBoletoTransaction(paymentId) {
+        try {
+            const client = await pagarme__default["default"].client.connect({ api_key: this.credentials.API_KEY });
+            const result = await client.transactions.find({ id: paymentId });
+            return result;
+        }
+        catch (error) {
+            throw new connect.BusinessError('Houve uma falha buscar o boleto com paymentId: ' + paymentId, {
+                paymentId,
+                info: error,
+            });
+        }
+    }
+    createBoletoPayment(checkout) {
+        return {
+            api_key: this.credentials.API_KEY,
+            amount: Math.floor(checkout.totalPrice * 100),
+            boleto_rules: ['strict_expiration_date'],
+            boleto_instructions: 'Sr. Caixa, NÃO aceitar o pagamento após o vencimento.',
+            boleto_expiration_date: connect.format(connect.addDays(new Date(), 3), 'yyyy-MM-dd'),
+            payment_method: 'boleto',
+            postback_url: this.credentials.URL_POSTBACK,
+            customer: {
+                external_id: checkout.user.id,
+                type: 'individual',
+                country: 'br',
+                name: checkout.user.displayName,
+                documents: [
+                    {
+                        type: 'cpf',
+                        number: checkout.user.cpf,
+                    },
+                ],
+            },
+        };
+    }
+}
+
+class PagarmeCardAPIAdapter {
+    constructor(credentials, paymentRepository, orderBlockedRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+        this.orderBlockedRepository = orderBlockedRepository;
+    }
+    async pay(checkout, card) {
+        try {
+            const client = await this.createPagarmeClient();
+            const transactionResult = await this.executeCardTransaction(client, checkout, card);
+            await this.validateTransactionResult(transactionResult, checkout, card);
+            return await this.createPaymentRecord(checkout, transactionResult);
+        }
+        catch (error) {
+            this.handlePaymentError(error, checkout);
+        }
+    }
+    async createPagarmeClient() {
+        return await pagarme__default["default"].client.connect({ api_key: this.credentials.API_KEY });
+    }
+    async executeCardTransaction(client, checkout, card) {
+        const payload = this.createCardPayment(checkout, card);
+        const result = await client.transactions.create(payload);
+        this.logTransactionDetails(payload, result);
+        return result;
+    }
+    logTransactionDetails(payload, result) {
+        console.warn('[PAGARME CARD DATA TO SEND]', payload);
+        console.warn('result PagarmeCardAPIAdapter', JSON.stringify(result));
+    }
+    async validateTransactionResult(result, checkout, card) {
+        if (result.status !== connect.PagarmePaymentStatus.Pago) {
+            await this.handleUnauthorizedPayment(checkout, card, result);
+        }
+    }
+    async handleUnauthorizedPayment(checkout, card, result) {
+        await this.createBlockedOrderRecord(checkout, card);
+        throw new connect.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: result,
+        });
+    }
+    async createBlockedOrderRecord(checkout, card) {
+        await this.orderBlockedRepository.createBlockedOrderOrPayment({
+            checkout,
+            blockType: 'Card not authorized',
+            type: 'Card',
+            limiteRange: 'day',
+            card,
+        });
+    }
+    async createPaymentRecord(checkout, transactionResult) {
+        return await this.paymentRepository.create({
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            userId: checkout.user.id,
+            checkoutId: checkout.id,
+            totalPrice: checkout.totalPrice,
+            paymentProvider: connect.PaymentProviders.PAGARME,
+            transaction: Object.assign(Object.assign({}, transactionResult), { paidAt: new Date() }),
+        });
+    }
+    handlePaymentError(error, checkout) {
+        console.error('Error PagarmeCardAPIAdapter', JSON.stringify(error));
+        throw new connect.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: error,
+        });
+    }
+    async addCard(card) {
+        try {
+            const client = await pagarme__default["default"].client.connect({ api_key: this.credentials.API_KEY });
+            const result = await client.cards.create({
+                card_number: card.number,
+                card_expiration_date: card.expirationDate.replace('/', ''),
+                card_holder_name: card.name,
+                card_cvv: card.cvv,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new connect.BusinessError('Houve uma falha adicionar o cartão', {
+                info: error,
+            });
+        }
+    }
+    async createCardHash(bu, card) {
+        try {
+            const client = await pagarme__default["default"].client.connect({ api_key: this.credentials.API_KEY });
+            const result = await client.security.encrypt({
+                card_number: card.number,
+                card_expiration_date: card.expirationDate.replace('/', ''),
+                card_holder_name: card.name,
+                card_cvv: card.cvv,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new connect.BusinessError('Houve uma falha ao gerar o hash do cartão', {
+                info: error,
+            });
+        }
+    }
+    async getCardByToken(id) {
+        try {
+            const client = await pagarme__default["default"].client.connect({ api_key: this.credentials.API_KEY });
+            const result = await client.cards.find({
+                id,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new connect.BusinessError('Houve uma falha buscar o cartão com id: ' + id, {
+                info: error,
+            });
+        }
+    }
+    async createTransaction(data) {
+        try {
+            const client = await pagarme__default["default"].client.connect({ api_key: this.credentials.API_KEY });
+            const result = await client.transactions.create(data);
+            return result;
+        }
+        catch (error) {
+            throw new connect.BusinessError('Houve uma falha ao criar a transação', {
+                info: error,
+            });
+        }
+    }
+    createCardPayment(checkout, card) {
+        var _a, _b, _c, _d, _e, _f;
+        return {
+            api_key: this.credentials.API_KEY,
+            amount: Math.floor(checkout.totalPrice * 100),
+            card_id: card.cardId,
+            card_cvv: card.cardCvv,
+            payment_method: 'credit_card',
+            installments: card.installments,
+            soft_descriptor: checkout.shop === connect.Shops.GLAMSHOP ? 'Glam' : "Men's Market",
+            customer: {
+                external_id: checkout.user.id,
+                name: checkout.user.displayName,
+                type: 'individual',
+                country: 'br',
+                email: checkout.user.email,
+                phone_numbers: checkout.user.phone ? ['+55' + checkout.user.phone] : '',
+                documents: [
+                    {
+                        type: 'cpf',
+                        number: checkout.user.cpf,
+                    },
+                ],
+            },
+            billing: {
+                name: checkout.user.displayName,
+                address: {
+                    country: 'br',
+                    state: checkout.billingAddress ? checkout.billingAddress.state : (_a = checkout.shippingAddress) === null || _a === void 0 ? void 0 : _a.state,
+                    city: checkout.billingAddress ? checkout.billingAddress.city : (_b = checkout.shippingAddress) === null || _b === void 0 ? void 0 : _b.city,
+                    neighborhood: checkout.billingAddress ? checkout.billingAddress.district : (_c = checkout.shippingAddress) === null || _c === void 0 ? void 0 : _c.district,
+                    street: checkout.billingAddress ? checkout.billingAddress.street : (_d = checkout.shippingAddress) === null || _d === void 0 ? void 0 : _d.street,
+                    street_number: checkout.billingAddress ? checkout.billingAddress.number : (_e = checkout.shippingAddress) === null || _e === void 0 ? void 0 : _e.number,
+                    zipcode: checkout.billingAddress
+                        ? checkout.billingAddress.zip.replace('-', '')
+                        : (_f = checkout.shippingAddress) === null || _f === void 0 ? void 0 : _f.zip.replace('-', ''),
+                },
+            },
+            items: checkout.lineItems.map((item) => {
+                return {
+                    id: item.id,
+                    title: checkout.user.isSubscriber ? `${item.name} - ASSINANTE` : item.name,
+                    unit_price: Math.floor(item.pricePaid * 100),
+                    quantity: item.quantity,
+                    tangible: true,
+                };
+            }),
+        };
+    }
+}
+
+class PagarmePixAPIAdapter {
+    constructor(credentials, paymentRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async pay(checkout) {
+        try {
+            const client = await pagarme__default["default"].client.connect({ api_key: this.credentials.API_KEY });
+            const payload = this.createPixPayment(checkout);
+            const result = await client.transactions.create(payload);
+            console.warn('[PAGARME PIX DATA TO SEND]', payload);
+            console.warn('result PagarmePixAPIAdapter', JSON.stringify(result));
+            const payment = await this.paymentRepository.create({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                userId: checkout.user.id,
+                checkoutId: checkout.id,
+                totalPrice: checkout.totalPrice,
+                paymentProvider: 'pagarMe',
+                transaction: result,
+            });
+            return payment;
+        }
+        catch (error) {
+            console.error('Error PagarmePixAPIAdapter', JSON.stringify(error));
+            throw new connect.PaymentError('Houve uma falha ao processar pagamento com pix', {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error,
+            });
+        }
+    }
+    createPixPayment(checkout) {
+        return {
+            payment_method: 'pix',
+            amount: Math.floor(checkout.totalPrice * 100),
+            api_key: this.credentials.API_KEY,
+            postback_url: this.credentials.URL_POSTBACK,
+            pix_expiration_date: connect.format(connect.addDays(new Date(), 1), 'yyyy-MM-dd'),
+            customer: {
+                external_id: checkout.user.id,
+                type: 'individual',
+                country: 'br',
+                name: checkout.user.displayName,
+                email: checkout.user.email.trim(),
+                phone_numbers: checkout.user.phone ? ['+55' + checkout.user.phone] : '',
+                documents: [
+                    {
+                        type: 'cpf',
+                        number: checkout.user.cpf,
+                    },
+                ],
+            },
+        };
+    }
+}
+
+class ProductVertexHelper {
+    constructor() { }
+    static productMapper(product) {
+        var _a, _b;
+        const image = product.miniatures && product.miniatures.length ? product.miniatures[0] : null;
+        return {
+            id: product.id.toString(),
+            miniatures: image,
+            icon: image,
+            name: product.name,
+            brand: ((_a = product.brand) === null || _a === void 0 ? void 0 : _a.toString().trim()) ? (_b = product.brand) === null || _b === void 0 ? void 0 : _b.toString().trim() : null,
+            ean: product.EAN,
+            sku: product.sku,
+            slug: product.slug,
+            published: product.published,
+            gender: product.gender,
+            stock: product.stock.quantity,
+            rating: product.rate,
+            shoppingCount: product.shoppingCount,
+            description: product.description.description,
+            fullPrice: product.fullPrice,
+            price: product.price.price,
+            subscriberPrice: product.subscriberPrice,
+            outlet: product.outlet,
+            createdAt: product.createdAt,
+        };
+    }
+    static resultProductMapper(result) {
+        return result[0].length
+            ? result[0].map((result) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+                return {
+                    id: (_a = result.document) === null || _a === void 0 ? void 0 : _a.structData.fields.id.stringValue,
+                    name: (_b = result.document) === null || _b === void 0 ? void 0 : _b.structData.fields.name.stringValue,
+                    brand: (_d = (_c = result.document) === null || _c === void 0 ? void 0 : _c.structData.fields.brand) === null || _d === void 0 ? void 0 : _d.stringValue,
+                    stock: (_f = (_e = result.document) === null || _e === void 0 ? void 0 : _e.structData.fields.stock) === null || _f === void 0 ? void 0 : _f.numberValue,
+                    rating: (_h = (_g = result.document) === null || _g === void 0 ? void 0 : _g.structData.fields.rating) === null || _h === void 0 ? void 0 : _h.stringValue,
+                    gender: (_k = (_j = result.document) === null || _j === void 0 ? void 0 : _j.structData.fields.gender) === null || _k === void 0 ? void 0 : _k.stringValue,
+                    slug: (_m = (_l = result.document) === null || _l === void 0 ? void 0 : _l.structData.fields.slug) === null || _m === void 0 ? void 0 : _m.stringValue,
+                    sku: (_p = (_o = result.document) === null || _o === void 0 ? void 0 : _o.structData.fields.sku) === null || _p === void 0 ? void 0 : _p.stringValue,
+                    ean: (_r = (_q = result.document) === null || _q === void 0 ? void 0 : _q.structData.fields.ean) === null || _r === void 0 ? void 0 : _r.stringValue,
+                    description: (_t = (_s = result.document) === null || _s === void 0 ? void 0 : _s.structData.fields.description) === null || _t === void 0 ? void 0 : _t.stringValue,
+                };
+            })
+            : [];
+    }
+}
+
+exports.DiscoveryEngineVertexAdapter = class DiscoveryEngineVertexAdapter {
+    constructor(configuration) {
+        this.config = configuration;
+        this.parentEngine =
+            `projects/${this.config.projectId}/locations/${this.config.location}/` +
+                `collections/default_collection/engines/${this.config.dataStoreId}`;
+        this.parentDataStore =
+            `projects/${this.config.projectId}/locations/${this.config.location}/` +
+                `collections/default_collection/dataStores/${this.config.dataStoreId}/branches/default_branch/documents`;
+        this.searchClient = new v1beta.SearchServiceClient({
+            apiEndpoint: configuration.apiEndpoint,
+            credentials: configuration.credentials,
+        });
+        this.documentClient = new discoveryengine.DocumentServiceClient({
+            apiEndpoint: configuration.apiEndpoint,
+            credentials: configuration.credentials,
+        });
+        this.servingConfig = this.searchClient.projectLocationCollectionDataStoreServingConfigPath(configuration.projectId, configuration.location, configuration.collectionId, configuration.dataStoreId, configuration.servingConfigId);
+    }
+    async save(product) {
+        const productSearch = ProductVertexHelper.productMapper(product);
+        const request = {
+            parent: this.parentEngine,
+            allowMissing: true,
+            document: {
+                name: this.parentDataStore + `/${product.id}`,
+                jsonData: JSON.stringify(productSearch),
+                data: 'jsonData',
+            },
+        };
+        const response = await this.documentClient.updateDocument(request);
+        return response;
+    }
+    async update(id, data) {
+        const productSearch = ProductVertexHelper.productMapper(data);
+        const request = {
+            parent: this.parentEngine,
+            allowMissing: true,
+            document: {
+                name: this.parentDataStore + `/${id}`,
+                jsonData: JSON.stringify(productSearch),
+                data: 'jsonData',
+            },
+        };
+        const response = await this.documentClient.updateDocument(request);
+        return response;
+    }
+    async query(term, total) {
+        const response = (await this.searchClient.search({
+            pageSize: total,
+            query: term,
+            filter: '',
+            languageCode: 'pt-BR',
+            servingConfig: this.servingConfig,
+            relevanceThreshold: 'MEDIUM',
+        }, {
+            autoPaginate: false,
+        }));
+        return ProductVertexHelper.resultProductMapper(response);
+    }
+    async get(id) {
+        const request = {
+            name: this.parentDataStore + `/${id}`,
+        };
+        const response = await this.documentClient.getDocument(request);
+        const document = JSON.parse(response[0].jsonData);
+        return document;
+    }
+    async delete(id) {
+        const request = {
+            name: this.parentDataStore + `/${id}`,
+        };
+        await this.documentClient.deleteDocument(request);
+    }
+    async bulkProducts(products) {
+        try {
+            const batchSize = 100;
+            let total = 0;
+            for (let index = 0; index < products.length; index += batchSize) {
+                const bulkProducts = products.slice(index, index + batchSize);
+                const [operation] = await this.documentClient.importDocuments({
+                    parent: `projects/${this.config.projectId}/locations/${this.config.location}/` +
+                        `collections/default_collection/dataStores/${this.config.dataStoreId}/branches/default_branch`,
+                    inlineSource: {
+                        documents: bulkProducts,
+                    },
+                });
+                total += bulkProducts.length;
+                const [response] = await operation.promise();
+                console.warn(`Imported: ${total} documents`, ((total / products.length) * 100).toFixed(2) + '%', 'Erros: ', response.errorSamples ? response.errorSamples : []);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+};
+exports.DiscoveryEngineVertexAdapter = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(VERTEX_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], exports.DiscoveryEngineVertexAdapter);
+
+var NestElasticSeachModule_1;
+exports.NestElasticSeachModule = NestElasticSeachModule_1 = class NestElasticSeachModule {
+    static initializeApp(options) {
+        return {
+            module: NestElasticSeachModule_1,
+            providers: [{ provide: ES_CONFIG, useValue: options }],
+            exports: [ES_CONFIG],
+        };
+    }
+};
+exports.NestElasticSeachModule = NestElasticSeachModule_1 = __decorate([
+    common.Module({
+        providers: [
+            exports.NativeElasticSearchAdapter,
+            {
+                provide: connect.ProductsIndex,
+                useFactory: (adapter) => new connect.ProductsIndex(adapter),
+                inject: [exports.NativeElasticSearchAdapter],
+            },
+        ],
+        exports: [connect.ProductsIndex],
+    })
+], exports.NestElasticSeachModule);
+
+exports.NestStorageModule = class NestStorageModule {
+};
+exports.NestStorageModule = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: FIREBASE_STORAGE,
+                useFactory: (firebaseAdmin) => firebaseAdmin.storage,
+                inject: [nestjsFirebase.FirebaseConstants.FIREBASE_TOKEN],
+            },
+        ],
+        exports: [FIREBASE_STORAGE],
+    })
+], exports.NestStorageModule);
+
+var NestFirestoreModule_1;
+exports.NestFirestoreModule = NestFirestoreModule_1 = class NestFirestoreModule {
+    static initializeApp(options) {
+        var _a;
+        return {
+            module: NestFirestoreModule_1,
+            imports: [
+                nestjsFirebase.FirebaseModule.forRoot({
+                    googleApplicationCredential: (_a = options === null || options === void 0 ? void 0 : options.firebase) === null || _a === void 0 ? void 0 : _a.googleApplicationCredential,
+                }),
+                exports.NestStorageModule,
+            ],
+            exports: [nestjsFirebase.FirebaseModule, exports.NestStorageModule],
+        };
+    }
+};
+exports.NestFirestoreModule = NestFirestoreModule_1 = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: exports.ConnectFirestoreService,
+                useFactory: (firebaseAdmin) => new exports.ConnectFirestoreService(firebaseAdmin.firestore),
+                inject: [nestjsFirebase.FirebaseConstants.FIREBASE_TOKEN],
+            },
+            {
+                provide: 'FirestoreOptions',
+                useFactory: (connectFirestoreService) => ({
+                    firestore: connectFirestoreService,
+                }),
+                inject: [exports.ConnectFirestoreService],
+            },
+            {
+                provide: 'BeautyProfileRepository',
+                useFactory: (config, userRepository) => {
+                    return new connect.UserBeautyProfileFirestoreRepository(config, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'Buy2WinRepository',
+                useFactory: (options) => {
+                    return new connect.Buy2WinFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: connect.CategoryFirestoreRepository,
+                useFactory: (options) => {
+                    return new connect.CategoryFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CheckoutRepository',
+                useFactory: (options) => {
+                    return new connect.CheckoutFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CheckoutSubscriptionRepository',
+                useFactory: (options) => {
+                    return new connect.CheckoutSubscriptionFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CouponRepository',
+                useFactory: (options) => {
+                    return new connect.CouponFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CampaignHashtagRepository',
+                useFactory: (options) => {
+                    return new connect.CampaignHashtagFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CampaignDashboardRepository',
+                useFactory: (options) => {
+                    return new connect.CampaignDashboardFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'EditionRepository',
+                useFactory: (options, subscriptionRepository) => {
+                    return new connect.SubscriptionEditionFirestoreRepository(options, subscriptionRepository);
+                },
+                inject: ['FirestoreOptions', 'SubscriptionRepository'],
+            },
+            {
+                provide: 'GroupRepository',
+                useFactory: (options) => {
+                    return new connect.GroupFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'HomeRepository',
+                useFactory: (options) => {
+                    return new connect.HomeFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LeadRepository',
+                useFactory: (options) => {
+                    return new connect.LeadFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LegacyOrderRepository',
+                useFactory: (options) => {
+                    return new connect.LegacyOrderFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'ShopMenuRepository',
+                useFactory: (options) => {
+                    return new connect.ShopMenuFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'OrderRepository',
+                useFactory: (options) => {
+                    return new connect.OrderFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'PaymentRepository',
+                useFactory: (options) => {
+                    return new connect.PaymentFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: connect.ProductFirestoreRepository,
+                useFactory: (options) => {
+                    return new connect.ProductFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'ShopSettingsRepository',
+                useFactory: (options) => {
+                    return new connect.ShopSettingsFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionPaymentRepository',
+                useFactory: (options, subscriptionRepository) => {
+                    return new connect.SubscriptionPaymentFirestoreRepository(options, subscriptionRepository);
+                },
+                inject: ['FirestoreOptions', 'SubscriptionRepository'],
+            },
+            {
+                provide: 'SubscriptionPlanRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionPlanFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionProductRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionProductFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'UserRepository',
+                useFactory: (options) => {
+                    return new connect.UserFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'UserAddressRepository',
+                useFactory: (options, userRepository) => {
+                    return new connect.UserAddressFirestoreRepository(options, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'UserPaymentMethodRepository',
+                useFactory: (options, userRepository) => {
+                    return new connect.UserPaymentMethodFirestoreRepository(options, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'SubscriptionMaterializationRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionMaterializationFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionSummaryRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionSummaryFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: connect.ProductVariantFirestoreRepository,
+                useFactory: (options, productRepository) => {
+                    return new connect.ProductVariantFirestoreRepository(options, productRepository);
+                },
+                inject: ['FirestoreOptions', connect.ProductFirestoreRepository],
+            },
+            {
+                provide: 'OrderBlockedRepository',
+                useFactory: (options) => {
+                    return new connect.OrderBlockedFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LogRepository',
+                useFactory: (options) => {
+                    return new connect.LogFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SequenceRepository',
+                useFactory: (options) => {
+                    return new connect.SequenceFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+        ],
+        exports: [
+            'BeautyProfileRepository',
+            'Buy2WinRepository',
+            connect.CategoryFirestoreRepository,
+            'CheckoutRepository',
+            'CheckoutSubscriptionRepository',
+            'CouponRepository',
+            'CampaignHashtagRepository',
+            'CampaignDashboardRepository',
+            'EditionRepository',
+            'GroupRepository',
+            'HomeRepository',
+            'LeadRepository',
+            'LegacyOrderRepository',
+            'ShopMenuRepository',
+            'OrderRepository',
+            'OrderBlockedRepository',
+            'PaymentRepository',
+            'SequenceRepository',
+            'LogRepository',
+            connect.ProductFirestoreRepository,
+            'ShopSettingsRepository',
+            'SubscriptionPaymentRepository',
+            'SubscriptionPlanRepository',
+            'SubscriptionProductRepository',
+            'SubscriptionRepository',
+            'UserRepository',
+            'UserAddressRepository',
+            'UserPaymentMethodRepository',
+            'SubscriptionMaterializationRepository',
+            'SubscriptionSummaryRepository',
+            connect.ProductVariantFirestoreRepository,
+            exports.ConnectFirestoreService,
+        ],
+    })
+], exports.NestFirestoreModule);
+
+var NestHasuraGraphQLModule_1;
+exports.NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = class NestHasuraGraphQLModule {
+    static initializeApp(options) {
+        return {
+            module: NestHasuraGraphQLModule_1,
+            providers: [{ provide: HASURA_OPTIONS, useValue: options }],
+            exports: [HASURA_OPTIONS],
+        };
+    }
+};
+exports.NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: 'HasuraConfig',
+                useFactory: (options) => ({
+                    endpoint: options.endpoint,
+                    authOptions: options.credentials,
+                    cache: options.cache,
+                }),
+                inject: [HASURA_OPTIONS],
+            },
+            {
+                provide: 'CategoryRepository',
+                useExisting: connect.CategoryHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.CategoryHasuraGraphQLRepository,
+                useFactory: (options, productRepository, categoryFilterRepository) => {
+                    return new connect.CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository);
+                },
+                inject: ['HasuraConfig', connect.ProductHasuraGraphQLRepository, connect.CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: 'ProductRepository',
+                useExisting: connect.ProductHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.ProductHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new connect.ProductHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'ProductReviewRepository',
+                useExisting: connect.ProductReviewHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.ProductReviewHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new connect.ProductReviewHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'VariantRepository',
+                useExisting: connect.VariantHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.VariantHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new connect.VariantHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'ProductStockNotificationRepository',
+                useExisting: connect.ProductStockNotificationHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.ProductStockNotificationHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new connect.ProductStockNotificationHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryFilterRepository',
+                useExisting: connect.CategoryFilterHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.CategoryFilterHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new connect.CategoryFilterHasuraGraphQLRepository(options);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'FilterOptionRepository',
+                useExisting: connect.FilterOptionHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.FilterOptionHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new connect.FilterOptionHasuraGraphQLRepository(options);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'FilterRepository',
+                useExisting: connect.FilterHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.FilterHasuraGraphQLRepository,
+                useFactory: (options, filterOptionRepository, categoryFilterRepository) => {
+                    return new connect.FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository);
+                },
+                inject: ['HasuraConfig', connect.FilterOptionHasuraGraphQLRepository, connect.CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: connect.CategoryCollectionChildrenHasuraGraphQLRepository,
+                useFactory: (options) => new connect.CategoryCollectionChildrenHasuraGraphQLRepository(options),
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryCollectionChildrenRepository',
+                useExisting: connect.CategoryCollectionChildrenHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.CategoryProductHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new connect.CategoryProductHasuraGraphQLRepository(options);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryProductRepository',
+                useExisting: connect.CategoryProductHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.WishlistHasuraGraphQLRepository,
+                useFactory: (options, categoryProductRepository) => {
+                    return new connect.WishlistHasuraGraphQLRepository(options, categoryProductRepository);
+                },
+                inject: ['HasuraConfig', connect.CategoryProductHasuraGraphQLRepository],
+            },
+            {
+                provide: 'WishlistRepository',
+                useExisting: connect.WishlistHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.ProductErrorsHasuraGraphQLRepository,
+                useFactory: (options, productRepository) => {
+                    return new connect.ProductErrorsHasuraGraphQLRepository(options, productRepository);
+                },
+                inject: ['HasuraConfig', connect.ProductHasuraGraphQLRepository],
+            },
+            {
+                provide: 'ProductErrorsRepository',
+                useExisting: connect.ProductErrorsHasuraGraphQLRepository,
+            },
+        ],
+        exports: [
+            'CategoryRepository',
+            connect.CategoryHasuraGraphQLRepository,
+            'ProductRepository',
+            connect.ProductHasuraGraphQLRepository,
+            'ProductReviewRepository',
+            connect.ProductReviewHasuraGraphQLRepository,
+            'VariantRepository',
+            connect.VariantHasuraGraphQLRepository,
+            'ProductStockNotificationRepository',
+            connect.ProductStockNotificationHasuraGraphQLRepository,
+            'CategoryFilterRepository',
+            connect.CategoryFilterHasuraGraphQLRepository,
+            'FilterOptionRepository',
+            connect.FilterOptionHasuraGraphQLRepository,
+            'FilterRepository',
+            connect.FilterHasuraGraphQLRepository,
+            'CategoryCollectionChildrenRepository',
+            connect.CategoryCollectionChildrenHasuraGraphQLRepository,
+            'WishlistRepository',
+            connect.WishlistHasuraGraphQLRepository,
+            'CategoryProductRepository',
+            connect.CategoryProductHasuraGraphQLRepository,
+            'ProductErrorsRepository',
+            connect.ProductErrorsHasuraGraphQLRepository,
+        ],
+    })
+], exports.NestHasuraGraphQLModule);
+
+var NestVertexSeachModule_1;
+let NestVertexSeachModule = NestVertexSeachModule_1 = class NestVertexSeachModule {
+    static initializeApp(options) {
+        return {
+            module: NestVertexSeachModule_1,
+            providers: [{ provide: VERTEX_CONFIG, useValue: options }],
+            exports: [VERTEX_CONFIG],
+        };
+    }
+};
+NestVertexSeachModule = NestVertexSeachModule_1 = __decorate([
+    common.Module({
+        providers: [
+            exports.DiscoveryEngineVertexAdapter,
+            {
+                provide: connect.ProductsVertexSearch,
+                useFactory: (adapter) => new connect.ProductsVertexSearch(adapter),
+                inject: [exports.DiscoveryEngineVertexAdapter],
+            },
+        ],
+        exports: [connect.ProductsVertexSearch],
+    })
+], NestVertexSeachModule);
+
+var NestConnectModule_1;
+exports.NestConnectModule = NestConnectModule_1 = class NestConnectModule {
+    static initializeApp(options) {
+        return {
+            module: NestConnectModule_1,
+            imports: [
+                ...(options.firebase ? [exports.NestFirestoreModule.initializeApp({ firebase: options.firebase })] : []),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.hasura) ? [] : [exports.NestHasuraGraphQLModule.initializeApp(options.hasura)]),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.elasticSearch) ? [] : [exports.NestElasticSeachModule.initializeApp(options.elasticSearch)]),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.vertex) ? [] : [NestVertexSeachModule.initializeApp(options.vertex)]),
+            ],
+            exports: [
+                ...(options.firebase ? [exports.NestFirestoreModule] : []),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.hasura) ? [] : [exports.NestHasuraGraphQLModule]),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.elasticSearch) ? [] : [exports.NestElasticSeachModule]),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.vertex) ? [] : [NestVertexSeachModule]),
+            ],
+        };
+    }
+};
+exports.NestConnectModule = NestConnectModule_1 = __decorate([
+    common.Module({})
+], exports.NestConnectModule);
+
+exports.ConnectCollectionService = ConnectCollectionService;
+exports.ConnectDocumentService = ConnectDocumentService;
+exports.ES_CONFIG = ES_CONFIG;
+exports.FIREBASE_STORAGE = FIREBASE_STORAGE;
+exports.HASURA_OPTIONS = HASURA_OPTIONS;
+exports.PagarmeBankSlipAPIAdapter = PagarmeBankSlipAPIAdapter;
+exports.PagarmeCardAPIAdapter = PagarmeCardAPIAdapter;
+exports.PagarmePixAPIAdapter = PagarmePixAPIAdapter;
+exports.ProductVertexHelper = ProductVertexHelper;
+exports.VERTEX_CONFIG = VERTEX_CONFIG;