Cloud Functions — a Firebase szerveroldala

// V2: separate imports per type
import { onRequest, onCall } from 'firebase-functions/v2/https';
import { onDocumentCreated } from 'firebase-functions/v2/firestore';
import { onSchedule } from 'firebase-functions/v2/scheduler';

// HTTP endpoint
export const api = onRequest(
  { region: 'europe-west1', memory: '512MiB' },
  (req, res) => {
    res.json({ ok: true });
  }
);

// Firestore trigger
export const onOrderCreated = onDocumentCreated(
  { document: 'orders/{orderId}', region: 'europe-west1' },
  async (event) => {
    const order = event.data?.data();
    // ...
  }
);

import { onCall, HttpsError } from 'firebase-functions/v2/https';
import { getAuth } from 'firebase-admin/auth';

export const setUserRole = onCall(
  { region: 'europe-west1', enforceAppCheck: true },
  async (request) => {
    // request.auth is automatically read from the JWT
    if (request.auth?.token.role !== 'admin') {
      throw new HttpsError('permission-denied', 'Admin only');
    }

    const { uid, role } = request.data;
    await getAuth().setCustomUserClaims(uid, { role });
    return { success: true };
  }
);

import { getFunctions, httpsCallable } from 'firebase/functions';

const functions = getFunctions(app, 'europe-west1');
const setUserRole = httpsCallable(functions, 'setUserRole');

await setUserRole({ uid: 'usr_abc', role: 'editor' });

export const api = onRequest(
  {
    region: 'europe-west1',
    memory: '512MiB',
    minInstances: 1,             // always 1 instance running
  },
  (req, res) => { /* ... */ }
);

import { initializeApp } from 'firebase-admin/app';
import { getFirestore } from 'firebase-admin/firestore';
import Stripe from 'stripe';

// Initialised once, reused across all warm calls
initializeApp();
const db = getFirestore();
const stripe = new Stripe(process.env.STRIPE_KEY!);

export const api = onRequest(async (req, res) => {
  // db and stripe are ready — no per-call initialisation
  await db.collection('logs').add({ ts: new Date() });
  res.json({ ok: true });
});

export const api = onRequest(
  {
    region: 'europe-west1',
    memory: '512MiB',
    concurrency: 80,             // default
  },
  (req, res) => { /* ... */ }
);

// BAD — the variable is shared across requests!
let currentUserId: string | null = null;

export const api = onCall(async (request) => {
  currentUserId = request.auth?.uid;        // ← race condition
  await someAsync();
  return { user: currentUserId };           // ← may have flipped to another user
});

// GOOD — each request has its own local variable
export const api = onCall(async (request) => {
  const userId = request.auth?.uid;
  await someAsync();
  return { user: userId };
});

export const api = onRequest(
  { region: ['europe-west1', 'us-central1', 'asia-east1'] },
  (req, res) => { /* ... */ }
);

# Deploy every function
$ firebase deploy --only functions

# Just one specific function (faster)
$ firebase deploy --only functions:setUserRole

# Just one "group" (if you've defined groups)
$ firebase deploy --only functions:webhooks

// BAD — every update fires the trigger again
export const updateTimestamp = onDocumentUpdated(
  'orders/{orderId}',
  async (event) => {
    await event.data?.after.ref.update({
      lastModified: new Date(),
    });                                  // ← re-triggers itself!
  }
);

export const updateTimestamp = onDocumentUpdated(
  'orders/{orderId}',
  async (event) => {
    const before = event.data?.before.data();
    const after = event.data?.after.data();

    // Only update when something "real" actually changed
    if (before?.status === after?.status &&
        before?.total === after?.total) {
      return;                              // do nothing
    }

    await event.data?.after.ref.update({
      lastModified: new Date(),
    });
  }
);

export const updateOrderStats = onDocumentWritten(
  'orders/{orderId}',
  async (event) => {
    // Writes to a different collection — won't re-trigger
    await db.doc('orderStats/global').set({
      lastChangeAt: new Date(),
      total: FieldValue.increment(1),
    }, { merge: true });
  }
);

// BAD — every run bumps the counter
export const countOrder = onDocumentCreated(
  'orders/{id}',
  async (event) => {
    await db.doc('stats/orders').update({
      count: FieldValue.increment(1),       // ← runs twice → counts twice
    });
  }
);

// GOOD — uses event.id to prevent duplication
export const countOrder = onDocumentCreated(
  'orders/{id}',
  async (event) => {
    const processedRef = db.doc(`processed/${event.id}`);
    const alreadyDone = (await processedRef.get()).exists;
    if (alreadyDone) return;             // already handled

    await db.runTransaction(async (tx) => {
      tx.update(db.doc('stats/orders'), {
        count: FieldValue.increment(1),
      });
      tx.set(processedRef, { at: new Date() });
    });
  }
);

import { logger } from 'firebase-functions/v2';

logger.info('New order received', {
  orderId: order.id,
  userId: order.userId,
  total: order.total,
});

logger.error('Stripe API error', {
  err: error.message,
  orderId: order.id,
});

# One-time setup
$ firebase init emulators

# Start (Functions + Firestore + Auth)
$ firebase emulators:start

# Just one specific emulator
$ firebase emulators:start --only functions,firestore

import { initializeApp } from 'firebase-functions-test';
import { setUserRole } from './index';

const testEnv = initializeApp();

describe('setUserRole', () => {
  it('an admin user can set the role', async () => {
    const wrapped = testEnv.wrap(setUserRole);
    const result = await wrapped({
      data: { uid: 'usr_abc', role: 'editor' },
      auth: { uid: 'admin_uid', token: { role: 'admin' } },
    });
    expect(result.success).toBe(true);
  });
});

// BAD — the user waits, the function pays
export const placeOrder = onCall(async (request) => {
  const order = await createOrder();
  await sendConfirmationEmail(order);     // 5 sec
  await notifySlack(order);                // 3 sec
  await syncToCRM(order);                  // 8 sec
  return order;
});

// GOOD — returns fast; the rest runs in the background via a Firestore trigger
export const placeOrder = onCall(async (request) => {
  const order = await createOrder();
  return order;                          // 200 ms
});