Multi-Tenant POS System

namespace App\Traits;

use App\Models\Scopes\TenantScope;
use Illuminate\Support\Facades\Auth;

trait BelongsToTenant
{
    /**
     * Boot the trait to attach global tenant scopes.
     */
    public static function bootBelongsToTenant()
    {
        static::addGlobalScope(new TenantScope);

        // Auto-assign tenant_id during model creation
        static::creating(function ($model) {
            if (! $model->tenant_id && Auth::check()) {
                $model->tenant_id = Auth::user()->tenant_id;
            }
        });
    }
}

namespace App\Models\Scopes;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Scope;
use Illuminate\Support\Facades\Auth;

class TenantScope implements Scope
{
    public function apply(Builder $builder, Model $model)
    {
        if (Auth::check()) {
            $builder->where($model->getTable() . '.tenant_id', Auth::user()->tenant_id);
        }
    }
}

import { openDB } from "idb";

// Initialize local IndexDB catalog cache
export async function initLocalCatalogDB() {
  return openDB("POSCatalog", 1, {
    upgrade(db) {
      if (!db.objectStoreNames.contains("products")) {
        const store = db.createObjectStore("products", { keyPath: "id" });
        store.createIndex("barcode", "barcode", { unique: true });
      }
    },
  });
}

// React scanning hook resolving queries locally in < 2ms
export function usePOSScanner(dbPromise) {
  const handleBarcodeScan = async (barcode, currentCart, onUpdate) => {
    const db = await dbPromise;
    const item = await db.getFromIndex("products", "barcode", barcode);
    
    if (item) {
      const existing = currentCart.find((i) => i.id === item.id);
      if (existing) {
        onUpdate(currentCart.map((i) => 
          i.id === item.id ? { ...i, qty: i.qty + 1 } : i
        ));
      } else {
        onUpdate([...currentCart, { ...item, qty: 1 }]);
      }
    }
  };

  return { handleBarcodeScan };
}

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Order;
use App\Models\Product;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class POSCheckoutController extends Controller
{
    public function processSale(Request $request)
    {
        $validated = $request->validate([
            'items' => 'required|array',
            'items.*.id' => 'required|exists:products,id',
            'items.*.qty' => 'required|integer|min:1',
            'payment_method' => 'required|string',
        ]);

        return DB::transaction(function () use ($validated) {
            $totalAmount = 0.00;
            $orderItems = [];

            foreach ($validated['items'] as $itemData) {
                // Lock product record for update to prevent concurrent stock depletion
                $product = Product::where('id', $itemData['id'])
                    ->lockForUpdate()
                    ->firstOrFail();

                if ($product->stock_count < $itemData['qty']) {
                    throw new \Exception("Insufficient stock for product: {$product->name}");
                }

                $product->decrement('stock_count', $itemData['qty']);
                $totalAmount += $product->price * $itemData['qty'];
                
                $orderItems[] = [
                    'product_id' => $product->id,
                    'quantity' => $itemData['qty'],
                    'price' => $product->price,
                ];
            }

            $order = Order::create([
                'payment_method' => $validated['payment_method'],
                'total_amount' => $totalAmount,
                'status' => 'completed',
            ]);

            $order->items()->createMany($orderItems);

            return response()->json([
                'success' => true,
                'order_id' => $order->id,
                'total' => $totalAmount,
            ]);
        });
    }
}