Backend Development Skill - Firebase & State Management

Memory-First Protocol (MANDATORY)

Before starting any task:

1. Query Memory MCP for existing backend patterns: mcp__memory__search_nodes
2. Load related store and API entities: mcp__memory__open_nodes

During task execution:

• Create store/API entities: mcp__memory__create_entities with type "Store" or "API"
• Add implementation details as observations: mcp__memory__add_observations
• Link stores to components and functions: mcp__memory__create_relations

Core Competencies

1. Firebase Services Management

• Firestore Operations: CRUD operations with proper user-scoped security
• Firebase Functions: Serverless backend logic and data processing
• Authentication Integration: User session and permission management
• Security Rules: Data access control and validation

2. State Management Architecture

• Zustand Stores: Domain-specific state management
• Optimistic Updates: Immediate UI updates with rollback capability
• Real-time Sync: Firestore subscriptions and live data updates
• Error Handling: Comprehensive error states and recovery

Implementation Patterns

Zustand Store Structure

interface StoreState {
  // Data state
  items: Item[];
  selectedItem: Item | null;
  
  // UI state
  isLoading: boolean;
  error: string | null;
  
  // Actions
  loadItems: () => Promise<void>;
  createItem: (item: CreateItemData) => Promise<void>;
  updateItem: (id: string, updates: Partial<Item>) => Promise<void>;
  deleteItem: (id: string) => Promise<void>;
  setSelectedItem: (item: Item | null) => void;
  clearError: () => void;
}

Firebase Security Model

// User-scoped collections pattern
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{userId}/{collection}/{docId} {
      allow read, write: if request.auth != null && request.auth.uid == userId;
    }
  }
}

Firebase Functions Pattern

export const createItem = functions.https.onCall(async (data, context) => {
  // Authentication check
  if (!context.auth) {
    throw new functions.https.HttpsError('unauthenticated', 'User must be authenticated');
  }
  
  // Validation
  const itemData = validateItemData(data);
  
  // Create with user scoping
  const item = {
    ...itemData,
    id: generateId(),
    userId: context.auth.uid,
    createdAt: new Date(),
    updatedAt: new Date()
  };
  
  await admin.firestore()
    .collection('users')
    .doc(context.auth.uid)
    .collection('items')
    .doc(item.id)
    .set(item);
    
  return { success: true, item };
});

Error Handling Pattern

const handleAsyncOperation = async (operation: () => Promise<void>, errorMessage: string) => {
  try {
    set({ isLoading: true, error: null });
    await operation();
    set({ isLoading: false });
  } catch (error) {
    console.error(`${errorMessage}:`, error);
    set({ 
      isLoading: false, 
      error: error instanceof Error ? error.message : errorMessage 
    });
  }
};

Optimistic Updates Pattern

const updateItemOptimistically = async (id: string, updates: Partial<Item>) => {
  const { items } = get();
  const originalItem = items.find(item => item.id === id);
  
  // Optimistic update
  set({
    items: items.map(item => 
      item.id === id ? { ...item, ...updates } : item
    )
  });
  
  try {
    await updateItemInFirestore(id, updates);
  } catch (error) {
    // Rollback on error
    if (originalItem) {
      set({
        items: items.map(item => 
          item.id === id ? originalItem : item
        )
      });
    }
    throw error;
  }
};

Data Validation with Zod

import { z } from 'zod';

export const itemSchema = z.object({
  name: z.string().min(1, 'Name is required'),
  description: z.string().optional(),
  status: z.enum(['ACTIVE', 'INACTIVE', 'ARCHIVED']),
  metadata: z.object({
    tags: z.array(z.string()).optional(),
    priority: z.number().int().min(1).max(5).optional(),
  }).optional(),
});

export const itemUpdateSchema = itemSchema.partial();

Quality Standards

Code Quality

• TypeScript Strict: Full type safety with proper interfaces
• Error Handling: Comprehensive error states and user feedback
• Performance: Efficient queries and minimal re-renders
• Security: Proper data access control and validation

Testing Requirements

• Unit Tests: Store actions and Firebase Functions
• Integration Tests: End-to-end data flow validation
• Security Tests: Access control and permission validation
• Performance Tests: Query efficiency and load testing

Reporting Template

## Backend Implementation: [Feature Name]

### Components Delivered
- Zustand stores implemented
- Firebase Functions deployed
- Security rules updated
- Validation schemas created

### Data Integration
- Store-component integration tested
- Real-time subscriptions functional
- Optimistic updates working
- Error handling validated

### Security Validation
- User-scoped access verified
- Input validation tested
- Authentication flows working
- Permission checks functional