Cloud Functions

functions/
├── index.js              # Main entry point and exports
├── mercadopago.js        # MercadoPago integration
├── addi.js               # ADDI payment integration
├── sistecredito.js       # Sistecrédito integration
├── cod.js                # Cash on delivery (Contra Entrega)
├── emails.js             # Email notifications
├── scheduler.js          # Scheduled maintenance tasks
├── whatsapp.js           # WhatsApp Business API
├── google-merchant.js    # Google Merchant Center feed
├── sitemap.js            # Dynamic sitemap generation
└── sync.js               # Product sync utilities

if (!admin.apps.length) {
    admin.initializeApp();
}

exports.createMercadoPagoPreference = functions.https.onCall(mpModule.createPreference);

async function getAddiToken() {
    const response = await axios.post(`${ADDI_AUTH_URL}/oauth/token`, {
        client_id: ADDI_CLIENT_ID,
        client_secret: ADDI_CLIENT_SECRET,
        audience: ADDI_AUDIENCE,
        grant_type: "client_credentials"
    });
    return response.data.access_token;
}

const SC_BASE_URL = "https://api.credinet.co/pay";
const SC_WEBHOOK_URL = "https://sistecreditowebhook-muiondpggq-uc.a.run.app";

await db.runTransaction(async (t) => {
    // Phase 1: Reads only
    for (const item of rawItems) {
        const pDoc = await t.get(pRef);
        // Validate stock, prepare updates
    }
    
    // Phase 2: Writes only
    for (const update of pendingUpdates) {
        t.update(update.ref, update.data);
    }
    t.set(newOrderRef, orderData);
    t.set(remissionRef, remissionData);
});

exports.sendOrderConfirmation = onDocumentCreated("orders/{orderId}", async (event) => {
    const orderData = event.data.data();
    const email = orderData.buyerInfo?.email;
    // Send email...
});

const transporter = nodemailer.createTransport({
    host: process.env.SMTP_HOST,
    port: parseInt(process.env.SMTP_PORT) || 465,
    secure: true,
    auth: {
        user: process.env.SMTP_EMAIL,
        pass: process.env.SMTP_PASSWORD
    }
});

exports.processScheduledTransfers = onSchedule({
    schedule: "5 0 * * *", 
    timeZone: "America/Bogota"
}, async (event) => {
    // Process pending transfers...
});

const sevenDaysAgo = new Date();
sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);

const snapshot = await db.collection('orders')
    .where('createdAt', '<', sevenDaysAgo)
    .where('status', 'in', ['PENDIENTE_PAGO', 'RECHAZADO', 'CANCELADO'])
    .get();

const timeout = new Date();
timeout.setMinutes(timeout.getMinutes() - 35);

const snapshot = await db.collection('orders')
    .where('status', '==', 'PENDIENTE_PAGO')
    .where('createdAt', '<=', timeoutTimestamp)
    .get();

const snapshot = await db.collection('products')
    .where('promoEndsAt', '<=', now)
    .get();

snapshot.docs.forEach((doc) => {
    if (p.originalPrice && p.originalPrice > 0) {
        batch.update(doc.ref, {
            price: p.originalPrice,
            originalPrice: 0,
            promoEndsAt: null
        });
    }
});

if (req.method === "GET") {
    if (req.query["hub.mode"] === "subscribe" && 
        req.query["hub.verify_token"] === VERIFY_TOKEN) {
        res.status(200).send(req.query["hub.challenge"]);
    }
}

const bogotaHour = parseInt(now.toLocaleString("en-US", {
    timeZone: "America/Bogota", 
    hour: "numeric", 
    hour12: false
}));

const isOutOfOffice = bogotaHour >= 20 || bogotaHour < 7;

exports.sendMessage = onCall(async (request) => {
    const { phoneNumber, message, type, mediaUrl } = request.data;
    const waId = await sendToMeta(phoneNumber, message, type, mediaUrl);
    // Save to Firestore...
});

const cacheSnap = await cacheRef.get();
if (cacheSnap.exists && req.query.rebuild !== 'true') {
    xmlMap = data.xmlMap || {};
    lastGenerated = data.lastGenerated || 0;
}

const changedSnap = await db.collection('products')
    .where('updatedAt', '>', new Date(lastGenerated))
    .get();

const sitemapXml = `<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
${urls}
</urlset>`;

res.set('Cache-Control', 'public, max-age=3600, s-maxage=7200');

if (newData.last_updated && 
    newData.last_updated.toMillis() > now.toMillis() - 10000) {
    return; // Skip if updated in last 10 seconds
}

# MercadoPago
MP_ACCESS_TOKEN=your_token

# ADDI
ADDI_CLIENT_ID=your_client_id
ADDI_CLIENT_SECRET=your_secret

# Sistecrédito
SC_API_KEY=your_api_key
SC_APP_KEY=your_app_key
SC_APP_TOKEN=your_token

# Email
SMTP_HOST=smtp.example.com
SMTP_PORT=465
SMTP_EMAIL=[email protected]
SMTP_PASSWORD=your_password

# WhatsApp
WHATSAPP_VERIFY_TOKEN=your_verify_token
WHATSAPP_API_TOKEN=your_api_token
WHATSAPP_PHONE_ID=your_phone_id

# Deploy all functions
firebase deploy --only functions

# Deploy specific function
firebase deploy --only functions:mercadoPagoWebhook

# Deploy with env vars
firebase functions:config:set somekey="somevalue"

# Start emulator suite
firebase emulators:start

# Test callable function
const result = await firebase.functions().httpsCallable('createCODOrder')(data);

# Test webhook with curl
curl -X POST https://localhost:5001/PROJECT_ID/us-central1/mercadoPagoWebhook \
  -H "Content-Type: application/json" \
  -d '{"id": "12345"}'

await db.runTransaction(async (t) => {
    // 1. Check if already processed
    if (oData.paymentStatus === 'PAID') return;
    
    // 2. Deduct stock
    for (const i of oData.items) {
        const pDoc = await t.get(pRef);
        let newStock = pData.stock - i.quantity;
        
        // Handle variants
        if (i.color || i.capacity) {
            const idx = combos.findIndex(c => 
                c.color === i.color && c.capacity === i.capacity
            );
            combos[idx].stock -= i.quantity;
        }
        
        t.update(pRef, { stock: newStock, combinations: combos });
    }
    
    // 3. Update treasury
    t.update(accountRef, { balance: increment });
    
    // 4. Create remission
    t.set(remissionRef, remissionData);
    
    // 5. Mark as paid
    t.update(orderRef, { status: 'PAGADO', paymentStatus: 'PAID' });
});

try {
    // Function logic
} catch (error) {
    console.error("Error context:", error);
    throw new functions.https.HttpsError('internal', error.message);
}