如何通过Firestore安全规则阻止已被订单引用的products文档删除？

Absolutely, you can set up Firestore security rules to block deletion of a products document that’s still referenced by orders—but there’s a key catch: Firestore rules don’t support efficient cross-collection queries to scan all orders for references. Instead, you’ll need to implement a reverse reference tracking system to make this work reliably. Here’s a step-by-step solution:

Step 1: Add Reverse Reference Tracking to Products #

First, modify your products documents to include a field that tracks how many orders reference them. A numeric referenceCount is the simplest and most efficient option:

// Example product document structure
{
  "name": "Product A",
  "price": 29.99,
  "referenceCount": 1 // Tracks the number of active orders referencing this product
}

Step 2: Enforce Atomic Updates for Order Operations #

You need to ensure that every order creation, update, or deletion adjusts the referenceCount of its referenced products. Use Firestore batched writes or transactions to guarantee these changes happen atomically, and enforce this logic via security rules.

Security Rules for Orders #

These rules make sure any order modification correctly updates the product reference counts:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /orders/{orderId} {
      // Allow order creation only if we increment reference counts for all linked products
      allow create: if request.resource.data.products is list &&
        request.resource.data.products.every(productId => 
          get(/databases/$(database)/documents/products/$(productId)).data.referenceCount + 1 == 
          request.resource.data.productUpdates[productId]
        );

      // Allow order updates only if we adjust counts for added/removed products
      allow update: if request.resource.data.products is list &&
        let oldProducts = resource.data.products;
        let newProducts = request.resource.data.products;
        let addedProducts = newProducts.where(p => !oldProducts.includes(p));
        let removedProducts = oldProducts.where(p => !newProducts.includes(p));
        
        addedProducts.every(productId => 
          get(/databases/$(database)/documents/products/$(productId)).data.referenceCount + 1 == 
          request.resource.data.productUpdates[productId]
        ) &&
        removedProducts.every(productId => 
          get(/databases/$(database)/documents/products/$(productId)).data.referenceCount - 1 == 
          request.resource.data.productUpdates[productId]
        );

      // Allow order deletion only if we decrement counts for all linked products
      allow delete: if resource.data.products is list &&
        resource.data.products.every(productId => 
          get(/databases/$(database)/documents/products/$(productId)).data.referenceCount - 1 == 
          request.resource.data.productUpdates[productId]
        );
    }
  }
}

Step 3: Block Product Deletion When References Exist #

Add a rule to the products collection that prevents deletion unless the referenceCount is zero:

match /products/{productId} {
  // Only allow deletion if no orders reference this product
  allow delete: if resource.data.referenceCount == 0;

  // Restrict referenceCount changes to only +/-1 (to prevent invalid updates)
  allow update: if request.resource.data.referenceCount is number &&
    abs(request.resource.data.referenceCount - resource.data.referenceCount) == 1;
}

Key Notes for Reliability #

• Atomicity is Critical: Always use batched writes or transactions when modifying orders and product reference counts. This ensures either both operations succeed or neither does, avoiding inconsistent states (like an order being created without updating the product count).
• Performance: Using a referenceCount is far more efficient than querying all orders for references—Firestore rules can’t handle full-collection queries efficiently, and they’d hit execution limits for large datasets.
• Edge Cases: Don’t forget to handle order updates that remove product references, or order deletions—both require decrementing the product’s referenceCount.
• Alternative: Reference List: If you need to track specific order IDs instead of just a count, use a referencingOrders array. The deletion rule would check if this array is empty, but array operations are less efficient for large numbers of references.

Example Workflow #

1. Create Product A with referenceCount: 0.
2. Create Order 1 referencing Product A: Use a batch write to add the order and increment Product A’s referenceCount to 1.
3. Try to delete Product A: Security rule blocks it (count is 1).
4. Delete Order 1: Use a batch write to delete the order and decrement Product A’s referenceCount to 0.
5. Delete Product A: Now allowed (count is 0).

This system ensures you can’t delete a product that’s still linked to active orders, as long as all order operations correctly update the reference tracking field.

内容的提问来源于stack exchange，提问作者Rogério R. Alcântara