export default class OrderDashboard extends LightningElement {
  @api recordId;

  @wire(getOrdersForAccount, { accountId: '$recordId' })
  orders;  // displays the order list

  async handleStatusUpdate(orderId) {
    await updateOrderStatus({ orderId, status: 'Shipped' });  // Module 10's imperative call
    // "orders" above is now STALE — recordId never changed, so the wire never re-ran
    // The screen still shows the OLD status, even though the database has the new one
  }
}

import { refreshApex } from '@salesforce/apex';

export default class OrderDashboard extends LightningElement {
  @api recordId;
  wiredOrdersResult;  // will store the FULL result object, not just the data

  @wire(getOrdersForAccount, { accountId: '$recordId' })
  wiredOrders(result) {
    this.wiredOrdersResult = result;  // store the WHOLE thing — needed for refreshApex later
    if (result.data) {
      this.orders = result.data;
    }
  }

  async handleStatusUpdate(orderId) {
    await updateOrderStatus({ orderId, status: 'Shipped' });
    await refreshApex(this.wiredOrdersResult);  // ✅ forces the wire to re-fetch fresh data
  }
}

import { LightningElement, api, wire } from 'lwc';
import { refreshApex } from '@salesforce/apex';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';
import getOrdersForAccount from '@salesforce/apex/OrderController.getOrdersForAccount';
import updateOrderStatus from '@salesforce/apex/OrderController.updateOrderStatus';

export default class OrderDashboard extends LightningElement {
  @api recordId;
  orders;
  wiredOrdersResult;
  isUpdating = false;

  @wire(getOrdersForAccount, { accountId: '$recordId' })
  wiredOrders(result) {
    this.wiredOrdersResult = result;
    if (result.data) this.orders = result.data;
  }

  async handleStatusUpdate(orderId) {
    this.isUpdating = true;
    try {
      await updateOrderStatus({ orderId, status: 'Shipped' });
      await refreshApex(this.wiredOrdersResult);  // keeps the displayed list in sync
      this.dispatchEvent(new ShowToastEvent({
        title: 'Updated', message: 'Order marked as shipped.', variant: 'success'
      }));
    } catch (error) {
      this.dispatchEvent(new ShowToastEvent({
        title: 'Error', message: error.body?.message ?? 'Update failed', variant: 'error', mode: 'sticky'
      }));
    } finally {
      this.isUpdating = false;
    }
  }
}

// componentA.js
@wire(getRecord, { recordId: '$recordId', fields: [NAME_FIELD] })
account;

// componentB.js — completely separate component, same page
@wire(getRecord, { recordId: '$recordId', fields: [INDUSTRY_FIELD] })
account;

// Salesforce's LDS cache recognizes these reference the SAME record
// and intelligently shares/merges the underlying cached data,
// rather than each component independently hitting the server

// componentA.js — updates via LDS's updateRecord
import { updateRecord } from 'lightning/uiRecordApi';

async handleSave() {
  await updateRecord({
    fields: { Id: this.recordId, Name: 'New Account Name' }
  });
  // NO refreshApex() call here — yet componentB still updates!
}

// componentB.js — completely separate component
@wire(getRecord, { recordId: '$recordId', fields: [NAME_FIELD] })
account;
// This automatically reflects the new Name — LDS's shared cache
// recognized the update and pushed it to every component watching this record

@wire(getOrdersForAccount, { accountId: '001AAA' })  // cache key: (getOrdersForAccount, accountId=001AAA)
ordersForA;

@wire(getOrdersForAccount, { accountId: '001BBB' })  // DIFFERENT cache key — different parameters
ordersForB;
// These are treated as entirely separate cache entries — no confusion between them
// But calling getOrdersForAccount with accountId='001AAA' AGAIN later
// may serve from the existing cache rather than hitting the server fresh

// 1. Need to DISPLAY data, kept current automatically?
//    → @wire (standard adapter if it fits, custom Apex if not)

// 2. Standard need (single record, list view, object metadata)?
//    → Prefer standard adapters (getRecord, getListUi, getObjectInfo)
//    → Get LDS's shared caching AND auto-cross-component-sync for free

// 3. Custom query logic needed (joins, complex filters)?
//    → Custom Apex with @wire, remembering cacheable=true is required

// 4. One-time user-triggered ACTION (save, delete, search-on-click)?
//    → Imperative Apex call, with proper try/catch/finally

// 5. Imperative action changes data a wire is displaying?
//    → If updated via LDS's updateRecord: often auto-syncs, no extra step
//    → If updated via custom Apex DML: call refreshApex() explicitly afterward