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
Last updated