Examples

This section provides practical examples of using Buzzy Functions and Constants together to build powerful integrations and automations.

Weather API Integration

This example shows how to create a weather function that fetches data from an external API and displays it in your Buzzy app.

Constants Setup

// Create these constants in your app
WEATHER_API_KEY (secret) = "your-openweathermap-api-key"
WEATHER_API_URL = "https://api.openweathermap.org/data/2.5"
DEFAULT_UNITS = "metric"

Function Code

export const main = async (event) => {
  console.log('Weather function called with:', event);
  
  try {
    const { city, units } = event.body;
    
    if (!city) {
      return {
        statusCode: 400,
        body: { error: 'City parameter is required' }
      };
    }
    
    const apiKey = process.env.WEATHER_API_KEY;
    const baseUrl = process.env.WEATHER_API_URL;
    const weatherUnits = units || process.env.DEFAULT_UNITS;
    
    const response = await axios.get(`${baseUrl}/weather`, {
      params: {
        q: city,
        appid: apiKey,
        units: weatherUnits
      }
    });
    
    const weather = response.data;
    
    return {
      statusCode: 200,
      body: {
        success: true,
        city: weather.name,
        country: weather.sys.country,
        temperature: weather.main.temp,
        description: weather.weather[0].description,
        humidity: weather.main.humidity,
        windSpeed: weather.wind.speed,
        timestamp: new Date().toISOString()
      }
    };
  } catch (error) {
    console.error('Weather API error:', error);
    return {
      statusCode: 500,
      body: {
        success: false,
        error: error.message
      }
    };
  }
};

Function Environment Variables

WEATHER_API_KEY = BUZZYCONSTANTS('WEATHER_API_KEY')
WEATHER_API_URL = BUZZYCONSTANTS('WEATHER_API_URL')
DEFAULT_UNITS = BUZZYCONSTANTS('DEFAULT_UNITS')

Test Payload

{
  "city": "San Francisco",
  "units": "metric"
}

AI Chat Integration

Create an AI-powered chat function that integrates with OpenAI's GPT API and saves conversations to your Buzzy database.

Constants Setup

OPENAI_API_KEY (secret) = "sk-your-openai-api-key"
OPENAI_BASE_URL = "https://api.openai.com/v1"
OPENAI_MODEL = "gpt-4"
BUZZY_API_URL = "https://your-buzzy-instance.com"
BUZZY_API_EMAIL (secret) = "[email protected]"
BUZZY_API_PASSWORD (secret) = "your-buzzy-password"
CHAT_RESOURCE_ID = "your-chat-datatable-id"

Function Code

import { login, createMicroAppDataRow } from 'buzzy-api-nodejs';

export const main = async (event) => {
  console.log('AI Chat function called');
  
  try {
    const { message, userId, conversationId } = event.body;
    
    if (!message) {
      return {
        statusCode: 400,
        body: { error: 'Message is required' }
      };
    }
    
    // Call OpenAI API
    const openaiResponse = await axios.post(
      `${process.env.OPENAI_BASE_URL}/chat/completions`,
      {
        model: process.env.OPENAI_MODEL,
        messages: [
          { role: "user", content: message }
        ],
        max_tokens: 500
      },
      {
        headers: {
          'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    const aiResponse = openaiResponse.data.choices[0].message.content;
    
    // Authenticate with Buzzy
    const auth = await login({
      url: process.env.BUZZY_API_URL,
      email: process.env.BUZZY_API_EMAIL,
      password: process.env.BUZZY_API_PASSWORD
    });
    
    // Save conversation to Buzzy
    const chatRecord = await createMicroAppDataRow({
      authToken: auth.authToken,
      resourceId: process.env.CHAT_RESOURCE_ID,
      rowData: {
        user_message: message,
        ai_response: aiResponse,
        user_id: userId,
        conversation_id: conversationId,
        timestamp: new Date().toISOString(),
        model_used: process.env.OPENAI_MODEL
      }
    });
    
    return {
      statusCode: 200,
      body: {
        success: true,
        response: aiResponse,
        chatId: chatRecord.body._id,
        timestamp: new Date().toISOString()
      }
    };
  } catch (error) {
    console.error('AI Chat error:', error);
    return {
      statusCode: 500,
      body: {
        success: false,
        error: error.message
      }
    };
  }
};

Function Environment Variables

OPENAI_API_KEY = BUZZYCONSTANTS('OPENAI_API_KEY')
OPENAI_BASE_URL = BUZZYCONSTANTS('OPENAI_BASE_URL')
OPENAI_MODEL = BUZZYCONSTANTS('OPENAI_MODEL')
BUZZY_API_URL = BUZZYCONSTANTS('BUZZY_API_URL')
BUZZY_API_EMAIL = BUZZYCONSTANTS('BUZZY_API_EMAIL')
BUZZY_API_PASSWORD = BUZZYCONSTANTS('BUZZY_API_PASSWORD')
CHAT_RESOURCE_ID = BUZZYCONSTANTS('CHAT_RESOURCE_ID')

Stripe Webhook Handler

Handle Stripe payment webhooks and update your Buzzy application with payment status.

Constants Setup

STRIPE_WEBHOOK_SECRET (secret) = "whsec_your-webhook-secret"
STRIPE_SECRET_KEY (secret) = "sk_your-stripe-secret-key"
BUZZY_API_URL = "https://your-buzzy-instance.com"
BUZZY_API_EMAIL (secret) = "[email protected]"
BUZZY_API_PASSWORD (secret) = "your-buzzy-password"
ORDERS_RESOURCE_ID = "your-orders-datatable-id"

Function Code

import { login, updateMicroAppDataRow, getMicroAppDataRows } from 'buzzy-api-nodejs';
import crypto from 'crypto';

export const main = async (event) => {
  console.log('Stripe webhook received');
  
  try {
    // Verify webhook signature
    const signature = event.headers['stripe-signature'];
    const payload = event.body;
    
    const expectedSignature = crypto
      .createHmac('sha256', process.env.STRIPE_WEBHOOK_SECRET)
      .update(payload, 'utf8')
      .digest('hex');
    
    const signatureHeader = signature.split(',').reduce((acc, part) => {
      const [key, value] = part.split('=');
      acc[key] = value;
      return acc;
    }, {});
    
    if (signatureHeader.v1 !== expectedSignature) {
      return {
        statusCode: 401,
        body: { error: 'Invalid signature' }
      };
    }
    
    const webhookData = JSON.parse(payload);
    const { type, data } = webhookData;
    
    // Handle payment success
    if (type === 'payment_intent.succeeded') {
      const paymentIntent = data.object;
      const orderId = paymentIntent.metadata.order_id;
      
      if (orderId) {
        // Authenticate with Buzzy
        const auth = await login({
          url: process.env.BUZZY_API_URL,
          email: process.env.BUZZY_API_EMAIL,
          password: process.env.BUZZY_API_PASSWORD
        });
        
        // Find and update the order
        const orders = await getMicroAppDataRows({
          authToken: auth.authToken,
          resourceId: process.env.ORDERS_RESOURCE_ID,
          filters: { order_id: orderId }
        });
        
        if (orders.length > 0) {
          const order = orders[0];
          await updateMicroAppDataRow({
            authToken: auth.authToken,
            resourceId: process.env.ORDERS_RESOURCE_ID,
            rowID: order._id,
            rowData: {
              payment_status: 'paid',
              payment_intent_id: paymentIntent.id,
              amount_paid: paymentIntent.amount / 100,
              paid_at: new Date().toISOString()
            }
          });
        }
      }
    }
    
    return {
      statusCode: 200,
      body: { received: true }
    };
  } catch (error) {
    console.error('Stripe webhook error:', error);
    return {
      statusCode: 500,
      body: { error: error.message }
    };
  }
};

Function Configuration

Authentication Type: Specific Domains
Allowed Domains: ['https://hooks.stripe.com']

Data Synchronization

Sync data between your Buzzy app and an external CRM system.

Constants Setup

CRM_API_KEY (secret) = "your-crm-api-key"
CRM_BASE_URL = "https://api.yourcrm.com/v1"
BUZZY_API_URL = "https://your-buzzy-instance.com"
BUZZY_API_EMAIL (secret) = "[email protected]"
BUZZY_API_PASSWORD (secret) = "your-buzzy-password"
CONTACTS_RESOURCE_ID = "your-contacts-datatable-id"
SYNC_INTERVAL_HOURS = "24"

Function Code

import { login, getMicroAppDataRows, createMicroAppDataRow, updateMicroAppDataRow } from 'buzzy-api-nodejs';

export const main = async (event) => {
  console.log('Data sync function started');
  
  try {
    const { direction = 'both', lastSyncTime } = event.body;
    
    // Authenticate with Buzzy
    const auth = await login({
      url: process.env.BUZZY_API_URL,
      email: process.env.BUZZY_API_EMAIL,
      password: process.env.BUZZY_API_PASSWORD
    });
    
    let syncResults = {
      buzzyToExternal: 0,
      externalToBuzzy: 0,
      errors: []
    };
    
    // Sync from Buzzy to external CRM
    if (direction === 'both' || direction === 'to_external') {
      const buzzyContacts = await getMicroAppDataRows({
        authToken: auth.authToken,
        resourceId: process.env.CONTACTS_RESOURCE_ID,
        filters: lastSyncTime ? { updatedAt: { $gt: lastSyncTime } } : {}
      });
      
      for (const contact of buzzyContacts) {
        try {
          const crmData = {
            name: contact.full_name,
            email: contact.email,
            phone: contact.phone,
            company: contact.company,
            external_id: contact._id
          };
          
          const response = await axios.post(
            `${process.env.CRM_BASE_URL}/contacts`,
            crmData,
            {
              headers: {
                'Authorization': `Bearer ${process.env.CRM_API_KEY}`,
                'Content-Type': 'application/json'
              }
            }
          );
          
          // Update Buzzy record with CRM ID
          await updateMicroAppDataRow({
            authToken: auth.authToken,
            resourceId: process.env.CONTACTS_RESOURCE_ID,
            rowID: contact._id,
            rowData: {
              crm_id: response.data.id,
              last_synced: new Date().toISOString()
            }
          });
          
          syncResults.buzzyToExternal++;
        } catch (error) {
          syncResults.errors.push(`Failed to sync contact ${contact._id}: ${error.message}`);
        }
      }
    }
    
    // Sync from external CRM to Buzzy
    if (direction === 'both' || direction === 'to_buzzy') {
      const crmResponse = await axios.get(
        `${process.env.CRM_BASE_URL}/contacts`,
        {
          headers: {
            'Authorization': `Bearer ${process.env.CRM_API_KEY}`
          },
          params: lastSyncTime ? { updated_since: lastSyncTime } : {}
        }
      );
      
      for (const crmContact of crmResponse.data.contacts) {
        try {
          const buzzyData = {
            full_name: crmContact.name,
            email: crmContact.email,
            phone: crmContact.phone,
            company: crmContact.company,
            crm_id: crmContact.id,
            last_synced: new Date().toISOString()
          };
          
          // Check if contact already exists
          const existing = await getMicroAppDataRows({
            authToken: auth.authToken,
            resourceId: process.env.CONTACTS_RESOURCE_ID,
            filters: { crm_id: crmContact.id }
          });
          
          if (existing.length > 0) {
            // Update existing contact
            await updateMicroAppDataRow({
              authToken: auth.authToken,
              resourceId: process.env.CONTACTS_RESOURCE_ID,
              rowID: existing[0]._id,
              rowData: buzzyData
            });
          } else {
            // Create new contact
            await createMicroAppDataRow({
              authToken: auth.authToken,
              resourceId: process.env.CONTACTS_RESOURCE_ID,
              rowData: buzzyData
            });
          }
          
          syncResults.externalToBuzzy++;
        } catch (error) {
          syncResults.errors.push(`Failed to sync CRM contact ${crmContact.id}: ${error.message}`);
        }
      }
    }
    
    return {
      statusCode: 200,
      body: {
        success: true,
        syncResults,
        timestamp: new Date().toISOString()
      }
    };
  } catch (error) {
    console.error('Data sync error:', error);
    return {
      statusCode: 500,
      body: {
        success: false,
        error: error.message
      }
    };
  }
};

Email Notification System

Send automated emails using an external email service when certain conditions are met.

Constants Setup

SENDGRID_API_KEY (secret) = "SG.your-sendgrid-api-key"
FROM_EMAIL = "[email protected]"
FROM_NAME = "Your Company"
BUZZY_API_URL = "https://your-buzzy-instance.com"
BUZZY_API_EMAIL (secret) = "[email protected]"
BUZZY_API_PASSWORD (secret) = "your-buzzy-password"
NOTIFICATIONS_RESOURCE_ID = "your-notifications-datatable-id"

Function Code

import { login, createMicroAppDataRow } from 'buzzy-api-nodejs';

export const main = async (event) => {
  console.log('Email notification function called');
  
  try {
    const { 
      to, 
      subject, 
      message, 
      template = 'default',
      userId,
      triggerEvent 
    } = event.body;
    
    if (!to || !subject || !message) {
      return {
        statusCode: 400,
        body: { error: 'to, subject, and message are required' }
      };
    }
    
    // Send email via SendGrid
    const emailData = {
      personalizations: [{
        to: [{ email: to }],
        subject: subject
      }],
      from: {
        email: process.env.FROM_EMAIL,
        name: process.env.FROM_NAME
      },
      content: [{
        type: 'text/html',
        value: message
      }]
    };
    
    const emailResponse = await axios.post(
      'https://api.sendgrid.com/v3/mail/send',
      emailData,
      {
        headers: {
          'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    // Log notification in Buzzy
    const auth = await login({
      url: process.env.BUZZY_API_URL,
      email: process.env.BUZZY_API_EMAIL,
      password: process.env.BUZZY_API_PASSWORD
    });
    
    await createMicroAppDataRow({
      authToken: auth.authToken,
      resourceId: process.env.NOTIFICATIONS_RESOURCE_ID,
      rowData: {
        recipient: to,
        subject: subject,
        template: template,
        status: 'sent',
        user_id: userId,
        trigger_event: triggerEvent,
        sent_at: new Date().toISOString(),
        sendgrid_message_id: emailResponse.headers['x-message-id']
      }
    });
    
    return {
      statusCode: 200,
      body: {
        success: true,
        messageId: emailResponse.headers['x-message-id'],
        timestamp: new Date().toISOString()
      }
    };
  } catch (error) {
    console.error('Email notification error:', error);
    return {
      statusCode: 500,
      body: {
        success: false,
        error: error.message
      }
    };
  }
};

Best Practices from Examples

Security

Always use Constants for API keys and sensitive data
Verify webhook signatures for external integrations
Implement proper error handling and logging
Use environment variables instead of hardcoded values

Error Handling

Return appropriate HTTP status codes
Include descriptive error messages
Log errors for debugging
Implement graceful fallbacks where possible

Performance

Use async/await for better performance
Implement timeouts for external API calls
Cache frequently accessed data when appropriate
Monitor function execution time

Integration Patterns

Authenticate with Buzzy using the buzzy-api-nodejs client
Use consistent data structures for API responses
Implement proper data validation
Log important events for audit trails

Testing

Create comprehensive test payloads
Test error scenarios and edge cases
Verify external API integrations work correctly
Monitor function logs during testing

PreviousConstants NextAnalytics

Last updated 4 months ago

hashtagWeather API Integration

hashtagConstants Setup

hashtagFunction Code

hashtagFunction Environment Variables

hashtagTest Payload

hashtagAI Chat Integration

hashtagConstants Setup

hashtagFunction Code

hashtagFunction Environment Variables

hashtagStripe Webhook Handler

hashtagConstants Setup

hashtagFunction Code

hashtagFunction Configuration

hashtagData Synchronization

hashtagConstants Setup

hashtagFunction Code

hashtagEmail Notification System

hashtagConstants Setup

hashtagFunction Code

hashtagBest Practices from Examples

hashtagSecurity

hashtagError Handling

hashtagPerformance

hashtagIntegration Patterns

hashtagTesting

Weather API Integration

Constants Setup

Function Code

Function Environment Variables

Test Payload

AI Chat Integration

Constants Setup

Function Code

Function Environment Variables

Stripe Webhook Handler

Constants Setup

Function Code

Function Configuration

Data Synchronization

Constants Setup

Function Code

Email Notification System

Constants Setup

Function Code

Best Practices from Examples

Security

Error Handling

Performance

Integration Patterns

Testing