firebase-cloud-functions
$
npx mdskill add evanca/flutter-ai-rules/firebase-cloud-functionsInvoke Firebase Cloud Functions securely from Flutter apps.
- Enables backend logic execution directly within mobile applications.
- Integrates with Firebase Functions API and Flutter cloud_functions package.
- Automatically handles authentication, error reporting, and regional routing.
- Returns structured data results or error codes for immediate processing.
SKILL.md
.github/skills/firebase-cloud-functionsView on GitHub ↗
---
name: firebase-cloud-functions
description: Calls Firebase Cloud Functions from Flutter apps. Use when setting up callable functions, passing data to functions, handling errors from function calls, optimizing performance, or testing with the Firebase Emulator Suite.
---
# Firebase Cloud Functions Skill
This skill defines how to correctly call Firebase Cloud Functions from Flutter applications.
## When to Use
Use this skill when:
* Setting up and configuring Cloud Functions in a Flutter project.
* Calling callable functions and handling their results.
* Handling errors from function calls.
* Optimizing function call performance.
* Testing with the Firebase Emulator Suite.
---
## 1. Setup and Configuration
```
flutter pub add cloud_functions
```
```dart
import 'package:cloud_functions/cloud_functions.dart';
// After Firebase.initializeApp():
final functions = FirebaseFunctions.instance;
```
- Initialize Firebase before using any Cloud Functions features.
- For region-specific deployments, specify the region when getting the instance.
- Deploy callable functions to Firebase **before** attempting to call them from your Flutter app.
- Consider implementing **App Check** to prevent abuse of your Cloud Functions.
---
## 2. Calling Functions
Use `httpsCallable` to reference a function, then `call` to invoke it:
```dart
final result = await FirebaseFunctions.instance
.httpsCallable('functionName')
.call(data);
```
- Pass data as a `Map` — it is automatically serialized to JSON:
```dart
final result = await FirebaseFunctions.instance
.httpsCallable('addMessage')
.call({
"text": messageText,
"push": true,
});
```
- Access the result via the `data` property — it is automatically deserialized from JSON:
```dart
final responseData = result.data;
// Cast to expected type if needed:
final responseString = result.data as String;
```
- **Do not** pass authentication tokens in function parameters — they are automatically included by the SDK.
- Keep function names consistent between client code and server-side implementations.
---
## 3. Error Handling
Always wrap function calls in `try-catch` and check for `FirebaseFunctionsException`:
```dart
try {
final result = await FirebaseFunctions.instance
.httpsCallable('functionName')
.call(data);
// Handle successful result
} catch (e) {
if (e is FirebaseFunctionsException) {
print('Error code: ${e.code}');
print('Error message: ${e.message}');
print('Error details: ${e.details}');
} else {
print('Error: $e');
}
}
```
- Handle network connectivity issues and timeouts appropriately.
- Provide meaningful error messages to users when function calls fail.
- Consider implementing retry logic for transient errors.
---
## 4. Performance Optimization
Set a timeout appropriate to the expected execution time:
```dart
final callable = FirebaseFunctions.instance.httpsCallable(
'functionName',
options: HttpsCallableOptions(
timeout: const Duration(seconds: 30),
),
);
```
- Minimize the amount of data passed to and from functions to reduce latency.
- Use batch operations when possible to reduce the number of function calls.
- Consider client-side caching for frequently used function results.
- Monitor function performance in the Firebase Console to identify bottlenecks.
- Account for **cold starts** for infrequently used functions.
- Implement proper loading states in the UI while waiting for function responses.
---
## 5. Testing and Development
Use the Firebase Emulator Suite for local development and testing:
```dart
FirebaseFunctions.instance.useFunctionsEmulator('localhost', 5001);
```
- Test functions with both valid and invalid inputs to ensure proper validation.
- Verify that functions handle authentication correctly.
- Test with different user roles and permissions to ensure proper access control.
- Implement unit tests for client-side function calling logic.
- Use integration tests to verify end-to-end function behavior.
---
## References
- [Cloud Functions for Firebase Flutter documentation](https://firebase.google.com/docs/functions/callable?platform=flutter)
- [Firebase Emulator Suite](https://firebase.google.com/docs/emulator-suite)
More from evanca/flutter-ai-rules
- architecture-feature-firstStructures Flutter apps using layered architecture (UI / Logic / Data) with feature-first file organization. Use when creating new features, designing the project structure, adding repositories/services/view models (or cubits/providers/notifiers), or wiring dependency injection. State management agnostic.
- blocImplements Flutter state management using the bloc library (Bloc and Cubit). Use when creating new features, screens, or state management logic with bloc/cubit, modeling state, wiring Flutter widgets to blocs, or writing bloc/cubit unit tests.
- dart-3-updatesApplies Dart 3 language features in Flutter/Dart code. Use when writing if-else or switch statements, creating new classes, or deciding between a data class and a record.
- effective-dartApplies Effective Dart guidelines in Flutter/Dart code. Use when writing or reviewing Dart code for naming conventions, types, style, imports, file structure, usage patterns, documentation, testing, widgets, state management, or performance.
- firebase-aiIntegrates Firebase AI Logic into Flutter apps. Use when setting up the firebase_ai plugin, calling Gemini models, handling AI service errors, or applying security and privacy considerations for AI features.
- firebase-analyticsIntegrates Firebase Analytics into Flutter apps. Use when setting up analytics, logging events, setting user properties, or configuring event parameters.
- firebase-app-checkIntegrates Firebase App Check into Flutter apps. Use when setting up App Check, selecting providers per platform, using debug providers during development, enabling enforcement, or applying App Check security best practices.
- firebase-authIntegrates Firebase Authentication into Flutter apps. Use when setting up auth, managing auth state, implementing email/password or social sign-in, handling auth errors, managing users, or applying security best practices.
- firebase-cloud-firestoreIntegrates Cloud Firestore into Flutter apps. Use when setting up Firestore, designing document/collection structure, reading and writing data, working with real-time listeners, designing for scale, or applying security rules.
- firebase-crashlyticsIntegrates Firebase Crashlytics into Flutter apps. Use when setting up crash reporting, handling fatal and non-fatal errors, customizing crash reports with keys/logs/user identifiers, or configuring opt-in reporting.