Cloud Architecture GCP · Firebase · Cloud Functions · Firestore · Vertex AI

import {
  onDocumentCreated,
  onDocumentUpdated,
  onDocumentDeleted,
} from 'firebase-functions/v2/firestore'
import { publishEvent } from '../shared/pubsub'
import { logger } from '../shared/logger'

// Fires when a new product document is created
export const onProductCreated = onDocumentCreated(
  'products/{productId}',
  async (event) => {
    const data = event.data?.data()
    if (!data) return

    logger.info('Product created', { id: event.params.productId })

    // Publish to Pub/Sub — notif service handles it
    await publishEvent('product-events', {
      type:      'product.created',
      productId: event.params.productId,
      sellerId:  data.sellerId,
    })
  }
)

// Fires when any field in the order document changes
export const onOrderStatusChanged = onDocumentUpdated(
  'orders/{orderId}',
  async (event) => {
    const before = event.data?.before.data()
    const after  = event.data?.after.data()
    if (!before || !after) return

    // Only react to status field changes
    if (before.status === after.status) return

    await publishEvent('order-events', {
      type:     'order.status_changed',
      orderId:  event.params.orderId,
      from:     before.status,
      to:       after.status,
      userId:   after.userId,
    })
  }
)

import {
  beforeUserCreated,
  beforeUserSignedIn,
} from 'firebase-functions/v2/identity'
import { getAuth }       from 'firebase-admin/auth'
import { getFirestore } from 'firebase-admin/firestore'
import { HttpsError }   from 'firebase-functions/v2/https'

// Block registration from banned domains
export const beforeCreate = beforeUserCreated(async (event) => {
  const email = event.data.email ?? ''
  const bannedDomains = ['mailinator.com', 'tempmail.com']

  if (bannedDomains.some(d => email.endsWith(`@${d}`))) {
    throw new HttpsError('permission-denied', 'Email domain not allowed')
  }

  // Create user profile in Firestore automatically
  await getFirestore().collection('users').doc(event.data.uid).set({
    email,
    name:      event.data.displayName ?? '',
    role:      'user',
    createdAt: FieldValue.serverTimestamp(),
  })

  // Return custom claims — attached to JWT immediately
  return { customClaims: { role: 'user' } }
})

// Set RBAC custom claims on sign-in (refresh if role changed)
export const beforeSignIn = beforeUserSignedIn(async (event) => {
  const doc = await getFirestore()
    .collection('users').doc(event.data.uid).get()
  const role = doc.data()?.role ?? 'user'
  return { customClaims: { role } }
})

import {
  getFirestore, FieldValue, Timestamp,
  type DocumentData, type QuerySnapshot,
} from 'firebase-admin/firestore'
import type { Product, CreateProductInput } from './products.types'

const db = () => getFirestore()

export class ProductRepository {

  static col() { return db().collection('products') }

  static async findById(id: string): Promise<Product | null> {
    const doc = await ProductRepository.col().doc(id).get()
    return doc.exists ? ProductRepository.fromDoc(doc) : null
  }

  static async create(
    data: CreateProductInput, uid: string
  ): Promise<Product> {
    const ref = ProductRepository.col().doc()
    const doc = {
      ...data,
      id:        ref.id,
      sellerId:  uid,
      createdAt: FieldValue.serverTimestamp(),
      updatedAt: FieldValue.serverTimestamp(),
    }
    await ref.set(doc)
    return { ...doc, id: ref.id } as Product
  }

  static async listBySeller(
    sellerId: string,
    opts: { limit?: number; startAfter?: Timestamp } = {},
  ): Promise<Product[]> {
    let q = ProductRepository.col()
      .where('sellerId', '==', sellerId)
      .orderBy('createdAt', 'desc')
      .limit(opts.limit ?? 20)
    if (opts.startAfter) q = q.startAfter(opts.startAfter)
    const snap = await q.get()
    return snap.docs.map(ProductRepository.fromDoc)
  }

  static fromDoc = (doc: DocumentData): Product =>
    ({ id: doc.id, ...doc.data() } as Product)
}

import { getFirestore, FieldValue } from 'firebase-admin/firestore'

export class OrderService {

  // Atomic: decrement stock + create order in one transaction
  static async purchase(
    productId: string,
    quantity:  number,
    buyerId:   string,
  ) {
    const db = getFirestore()

    return db.runTransaction(async (txn) => {
      const productRef = db.collection('products').doc(productId)
      const product    = await txn.get(productRef)

      if (!product.exists) throw new Error('Product not found')

      const stock = product.data()!.stock
      if (stock < quantity) throw new Error('Insufficient stock')

      // Decrement stock atomically
      txn.update(productRef, {
        stock: FieldValue.increment(-quantity),
      })

      // Create order document
      const orderRef = db.collection('orders').doc()
      txn.set(orderRef, {
        productId, quantity, buyerId,
        status:    'pending',
        createdAt: FieldValue.serverTimestamp(),
      })

      return { orderId: orderRef.id }
    })
  }
}