DEV Community: Ruhul Amin Sujon

ব্যাকএন্ড ইঞ্জিনিয়ারের জন্য সিস্টেম ডিজাইন শেখা

Ruhul Amin Sujon — Tue, 10 Mar 2026 21:48:42 +0000

Q:1- System Design (scalability, microservices)
Answer:
🏗️ System Design কী?
System Design হলো এমন একটি প্রক্রিয়া যেখানে আপনি একটি বড় সফটওয়্যার সিস্টেমের আর্কিটেকচার, কম্পোনেন্ট, এবং ডেটা ফ্লো পরিকল্পনা করেন — যাতে সিস্টেমটি লক্ষ লক্ষ ইউজার হ্যান্ডেল করতে পারে, ক্র্যাশ না করে, এবং দ্রুত রেসপন্স দিতে পারে।
সহজ কথায়: আপনার অ্যাপ যখন ১০০ ইউজার থেকে ১০ মিলিয়ন ইউজারে যায় — তখন কী করবেন, সেটাই System Design।

📐 ১. Scalability (স্কেলেবিলিটি)
Scalability মানে হলো আপনার সিস্টেম বেশি লোড আসলে সেটা সামলাতে পারে কিনা।
দুই ধরনের Scaling আছে:
Vertical Scaling (Scale Up)
মানে আপনার সার্ভারের শক্তি বাড়ানো — বেশি RAM, বেশি CPU। কিন্তু এর একটা সীমা আছে এবং এটা ব্যয়বহুল।
Horizontal Scaling (Scale Out)
মানে একটা সার্ভারের বদলে অনেকগুলো সার্ভার ব্যবহার করা। Laravel-এ এটাই বেশি প্র্যাক্টিক্যাল।

[User] → [Load Balancer] → [Server 1]
                        → [Server 2]  
                        → [Server 3]

Laravel-এ Horizontal Scaling এর জন্য যা করতে হবে:
১. Session Shared করুন — একাধিক সার্ভারে session share করতে Redis ব্যবহার করুন:

php
// .env
SESSION_DRIVER=redis
CACHE_DRIVER=redis

// config/session.php
'driver' => env('SESSION_DRIVER', 'redis'),

২. File Storage Centralize করুন — সব সার্ভার যেন একই জায়গা থেকে ফাইল পায়:

php
// config/filesystems.php
'default' => env('FILESYSTEM_DISK', 's3'),

'disks' => [
    's3' => [
        'driver' => 's3',
        'key'    => env('AWS_ACCESS_KEY_ID'),
        'secret' => env('AWS_SECRET_ACCESS_KEY'),
        'region' => env('AWS_DEFAULT_REGION'),
        'bucket' => env('AWS_BUCKET'),
    ],
],

৩. Queue Centralize করুন — Jobs যেন যেকোনো সার্ভার প্রসেস করতে পারে:

php
// .env
QUEUE_CONNECTION=redis

// Job dispatch করুন
ProcessOrder::dispatch($order)->onQueue('orders');

// যেকোনো সার্ভারে worker চালান
php artisan queue:work redis --queue=orders

🔄 ২. Scalability Patterns
ক) Database Read/Write Separation
বেশিরভাগ অ্যাপে ৮০% Read, ২০% Write অপারেশন হয়। তাই Read আলাদা সার্ভারে পাঠানো স্মার্ট।

php
// config/database.php
'mysql' => [
    'read' => [
        'host' => [
            env('DB_READ_HOST_1', '192.168.1.2'),
            env('DB_READ_HOST_2', '192.168.1.3'),
        ],
    ],
    'write' => [
        'host' => [env('DB_WRITE_HOST', '192.168.1.1')],
    ],
    'driver'   => 'mysql',
    'database' => env('DB_DATABASE', 'myapp'),
    'username' => env('DB_USERNAME', 'root'),
    'password' => env('DB_PASSWORD', ''),
],

এখন Laravel নিজেই SELECT কে Read সার্ভারে এবং INSERT/UPDATE/DELETE কে Write সার্ভারে পাঠাবে।
খ) Caching Layer

php
// ডাটাবেজে বারবার না গিয়ে Cache থেকে নিন
public function getPopularProducts()
{
    return Cache::remember('popular_products', 3600, function () {
        return Product::where('is_popular', true)
                      ->with('category')
                      ->take(20)
                      ->get();
    });
}

গ) Queue দিয়ে Heavy Tasks আলাদা করুন

php
// ❌ ভুল — Request এর মধ্যেই Heavy কাজ করা
public function register(Request $request)
{
    $user = User::create($request->all());
    Mail::send(new WelcomeMail($user)); // এটা slow!
    Notification::send($user, new SmsNotification()); // এটাও slow!
    return response()->json(['success' => true]);
}

// ✅ সঠিক — Queue এ পাঠিয়ে দিন
public function register(Request $request)
{
    $user = User::create($request->all());
    SendWelcomeEmail::dispatch($user);   // Background এ যাবে
    SendWelcomeSms::dispatch($user);     // Background এ যাবে
    return response()->json(['success' => true]); // তৎক্ষণাৎ রেসপন্স
}

🧩 ৩. Microservices Architecture

Microservices মানে একটা বড় অ্যাপকে ছোট ছোট স্বাধীন সার্ভিসে ভাগ করা — যেগুলো আলাদাভাবে deploy ও scale করা যায়।

Monolith vs Microservices:

❌ Monolith (একটাই বড় অ্যাপ):

[User, Product, Order, Payment, Notification] → একটা Laravel App

✅ Microservices (আলাদা আলাদা সার্ভিস):

[User Service]        → api.myapp.com/users
[Product Service]     → api.myapp.com/products  
[Order Service]       → api.myapp.com/orders
[Payment Service]     → api.myapp.com/payments
[Notification Service]→ api.myapp.com/notifications

Microservices কখন দরকার?
আপনার অ্যাপ যদি এরকম হয়:

টিম বড় এবং আলাদা আলাদা টিম আলাদা ফিচারে কাজ করে
কিছু সার্ভিস বেশি scale দরকার (যেমন Payment আলাদা scale)
Different technology দরকার বিভিন্ন অংশে

Laravel-এ Microservices — Service Communication:
HTTP দিয়ে সার্ভিস কল করুন (Guzzle/Http Facade):

php
// Order Service থেকে Product Service কে কল করা
class OrderService
{
    public function createOrder(array $data)
    {
        // Product Service এ চেক করুন stock আছে কিনা
        $response = Http::withToken(config('services.product.token'))
                        ->get(config('services.product.url') . '/api/products/' . $data['product_id']);

        if (!$response->successful()) {
            throw new ServiceUnavailableException('Product service unreachable');
        }

        $product = $response->json();

        if ($product['stock'] < $data['quantity']) {
            throw new InsufficientStockException('Not enough stock');
        }

        // Order তৈরি করুন
        return Order::create([
            'user_id'    => $data['user_id'],
            'product_id' => $data['product_id'],
            'quantity'   => $data['quantity'],
            'total'      => $product['price'] * $data['quantity'],
        ]);
    }
}

Event-Driven Communication (RabbitMQ/Redis):

php
// Order Service — Event Publish করছে
class OrderController extends Controller
{
    public function store(Request $request)
    {
        $order = Order::create($request->validated());

        // Notification Service কে জানাও — সরাসরি কল না করে Event দিয়ে
        event(new OrderCreated($order));

        // অথবা Redis Pub/Sub দিয়ে
        Redis::publish('order.created', json_encode([
            'order_id' => $order->id,
            'user_id'  => $order->user_id,
            'total'    => $order->total,
        ]));

        return response()->json($order, 201);
    }
}

// Notification Service — Event Subscribe করছে
class OrderCreatedListener
{
    public function handle(OrderCreated $event)
    {
        // Email পাঠাও
        Mail::to($event->order->user->email)
            ->send(new OrderConfirmationMail($event->order));
    }
}

🚦 ৪. API Gateway Pattern

Microservices এ সব সার্ভিস আলাদা থাকলে Client কে একটাই Entry Point দেওয়া হয় — এটাই API Gateway।

[Mobile App]  ──┐
[Web App]     ──┤──→ [API Gateway] ──→ [User Service]
[Third Party] ──┘         │        ──→ [Product Service]
                          │        ──→ [Order Service]
                    (Auth, Rate Limit,
                     Logging, Routing)

Laravel-এ Simple API Gateway বানানো:

php
// routes/api.php — Gateway হিসেবে কাজ করবে
Route::middleware(['auth:sanctum', 'throttle:100,1'])->group(function () {

    // User Service এ forward করুন
    Route::any('/users/{path?}', function (Request $request, $path = '') {
        return Http::withToken($request->bearerToken())
                   ->send($request->method(),
                          config('services.user.url') . '/' . $path,
                          ['json' => $request->all()]);
    })->where('path', '.*');

    // Product Service এ forward করুন  
    Route::any('/products/{path?}', function (Request $request, $path = '') {
        return Http::send($request->method(),
                          config('services.product.url') . '/' . $path,
                          ['json' => $request->all()]);
    })->where('path', '.*');
});

📊 ৫. Real-world System Design Example

ধরুন আপনাকে একটা E-commerce সিস্টেম ডিজাইন করতে বলা হলো যেখানে ১০ লক্ষ ইউজার থাকবে:

                    ┌─────────────────────────────┐
                    │         CDN (CloudFront)     │  ← Static files, Images
                    └──────────────┬──────────────┘
                                   │
                    ┌──────────────▼──────────────┐
                    │      Load Balancer (Nginx)   │  ← Traffic distribute
                    └──────┬───────────┬───────────┘
                           │           │
              ┌────────────▼─┐    ┌────▼────────────┐
              │  Laravel App │    │  Laravel App     │  ← Multiple instances
              │  (Server 1)  │    │  (Server 2)      │
              └──────┬───────┘    └────┬─────────────┘
                     │                 │
        ┌────────────▼─────────────────▼────────────┐
        │                                            │
   ┌────▼────┐    ┌──────────┐    ┌───────────────┐  │
   │  Redis  │    │  MySQL   │    │  Elasticsearch│  │
   │ (Cache/ │    │ (Master) │    │  (Search)     │  │
   │  Queue/ │    │    │     │    └───────────────┘  │
   │ Session)│    │ Replica  │                        │
   └─────────┘    │ (Read)   │    ┌───────────────┐  │
                  └──────────┘    │  S3 (Storage) │  │
                                  └───────────────┘  │
        └────────────────────────────────────────────┘

এই ডিজাইনের প্রতিটা অংশের কাজ:
CDN — Images, CSS, JS ক্যাশ করে রাখে, সার্ভারে চাপ কমায়।
Load Balancer — Request গুলো Server 1 ও Server 2 এ ভাগ করে দেয়।
Redis — Session, Cache এবং Queue — তিনটাই হ্যান্ডেল করে।
MySQL Master-Replica — Master Write করে, Replica Read করে।
Elasticsearch — Product search দ্রুত করে।
S3 — User uploaded files রাখে।

🎯 ৬. Scalability Best Practices — Laravel এ

php
// ১. N+1 Query সমস্যা দূর করুন
// ❌ ভুল — প্রতিটা order এর জন্য আলাদা query
$orders = Order::all();
foreach ($orders as $order) {
    echo $order->user->name; // প্রতিবার DB hit!
}

// ✅ সঠিক — Eager Loading ব্যবহার করুন
$orders = Order::with(['user', 'products', 'payment'])->get();

// ২. Pagination ব্যবহার করুন — সব data একসাথে না নিয়ে
// ❌ ভুল
$products = Product::all(); // ১০ লক্ষ row!

// ✅ সঠিক
$products = Product::paginate(20);

// ৩. Chunk দিয়ে বড় ডেটা প্রসেস করুন
Product::chunk(1000, function ($products) {
    foreach ($products as $product) {
        // প্রতি ১০০০টা করে process হবে, memory overflow হবে না
        ProcessProduct::dispatch($product);
    }
});

// ৪. Database Index ব্যবহার করুন
Schema::table('orders', function (Blueprint $table) {
    $table->index(['user_id', 'status']);      // Composite Index
    $table->index('created_at');               // Date filter এর জন্য
});

// ৫. Rate Limiting — অতিরিক্ত Request ঠেকান
Route::middleware('throttle:60,1')->group(function () {
    Route::get('/products', [ProductController::class, 'index']);
});

🛡️ ৭. Fault Tolerance — সিস্টেম যেন ক্র্যাশ না করে

php
// Circuit Breaker Pattern — একটা সার্ভিস বন্ধ হলে পুরো সিস্টেম যেন না পড়ে
class PaymentService
{
    public function processPayment(Order $order)
    {
        try {
            $response = Http::timeout(5) // ৫ সেকেন্ডের বেশি অপেক্ষা না করা
                            ->retry(3, 1000) // ৩ বার try, ১ সেকেন্ড পরপর
                            ->post('https://payment-gateway.com/api/charge', [
                                'amount'   => $order->total,
                                'currency' => 'BDT',
                            ]);

            if ($response->failed()) {
                // Fallback — alternative payment method try করুন
                return $this->processWithAlternativeGateway($order);
            }

            return $response->json();

        } catch (ConnectionException $e) {
            // Gateway down — Queue তে রাখুন পরে retry করার জন্য
            RetryPayment::dispatch($order)->delay(now()->addMinutes(5));
            Log::error('Payment gateway down', ['order_id' => $order->id]);

            throw new PaymentGatewayException('Payment will be processed shortly');
        }
    }
}

📝 সংক্ষেপে মনে রাখুন
System Design এর মূল বিষয়গুলো হলো — Scalability মানে বেশি লোড সামলানোর ক্ষমতা (Horizontal > Vertical), Microservices মানে বড় সিস্টেমকে ছোট ছোট স্বাধীন সার্ভিসে ভাগ করা, Caching মানে ডাটাবেজে বারবার না গিয়ে দ্রুত ডেটা দেওয়া, Queue মানে ভারী কাজ Background এ করা, এবং Fault Tolerance মানে এক অংশ ভাঙলেও বাকি সিস্টেম চালু রাখা।

Q:2 - APIs (REST, GraphQL, gRPC)
Answer:

🌐 API কী?
API (Application Programming Interface) হলো দুটো সফটওয়্যারের মধ্যে কথা বলার নিয়ম। যেমন — আপনার Laravel অ্যাপ যখন Mobile App কে ডেটা দেয়, সেটা API এর মাধ্যমে হয়।

[Mobile App] ←──── API ────→ [Laravel Backend] ←──→ [Database]
[Web App]    ←──── API ────→ [Laravel Backend]
[Third Party]←──── API ────→ [Laravel Backend]

তিনটা প্রধান API টাইপ আছে — REST, GraphQL, এবং gRPC। প্রতিটার আলাদা সুবিধা ও ব্যবহার আছে।

🔵 PART 1 — REST API
REST API কী?
REST (Representational State Transfer) হলো সবচেয়ে জনপ্রিয় API স্টাইল। এটা HTTP Methods ব্যবহার করে ডেটা আদান-প্রদান করে।

GET    /api/products        → সব product দেখাও
GET    /api/products/5      → ৫ নম্বর product দেখাও
POST   /api/products        → নতুন product তৈরি করো
PUT    /api/products/5      → ৫ নম্বর product সম্পূর্ণ আপডেট করো
PATCH  /api/products/5      → ৫ নম্বর product আংশিক আপডেট করো
DELETE /api/products/5      → ৫ নম্বর product মুছে ফেলো

Laravel-এ Professional REST API বানানো
Step 1 — Route তৈরি করুন:

php
// routes/api.php
use App\Http\Controllers\Api\V1\ProductController;

// API Versioning — v1, v2 আলাদা রাখুন
Route::prefix('v1')->group(function () {

    // Public routes — Auth লাগবে না
    Route::get('/products', [ProductController::class, 'index']);
    Route::get('/products/{id}', [ProductController::class, 'show']);

    // Protected routes — Auth লাগবে
    Route::middleware('auth:sanctum')->group(function () {
        Route::post('/products', [ProductController::class, 'store']);
        Route::put('/products/{id}', [ProductController::class, 'update']);
        Route::delete('/products/{id}', [ProductController::class, 'destroy']);
    });
});

Step 2 — Form Request দিয়ে Validation:

php
// app/Http/Requests/Api/StoreProductRequest.php
class StoreProductRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'name'        => 'required|string|max:255',
            'price'       => 'required|numeric|min:0',
            'stock'       => 'required|integer|min:0',
            'category_id' => 'required|exists:categories,id',
            'description' => 'nullable|string|max:1000',
        ];
    }

    public function messages(): array
    {
        return [
            'name.required'        => 'পণ্যের নাম দিতে হবে',
            'price.required'       => 'দাম দিতে হবে',
            'category_id.exists'   => 'ক্যাটাগরি সঠিক নয়',
        ];
    }
}

Step 3 — API Resource দিয়ে Response Format করুন:

php
// app/Http/Resources/ProductResource.php
class ProductResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id'          => $this->id,
            'name'        => $this->name,
            'price'       => number_format($this->price, 2),
            'price_bdt'   => '৳ ' . number_format($this->price, 2),
            'stock'       => $this->stock,
            'in_stock'    => $this->stock > 0,
            'category'    => new CategoryResource($this->whenLoaded('category')),
            'images'      => ImageResource::collection($this->whenLoaded('images')),
            'created_at'  => $this->created_at->format('d M Y'),

            // Condition — শুধু Admin দেখবে
            'cost_price'  => $this->when(
                                auth()->user()?->isAdmin(),
                                $this->cost_price
                             ),
        ];
    }
}

// Collection Resource
class ProductCollection extends ResourceCollection
{
    public function toArray(Request $request): array
    {
        return [
            'data' => $this->collection,
            'meta' => [
                'total_products' => $this->total(),
                'current_page'   => $this->currentPage(),
            ],
        ];
    }
}

Step 4 — Controller লিখুন:

php
// app/Http/Controllers/Api/V1/ProductController.php
class ProductController extends Controller
{
    public function index(Request $request)
    {
        $products = Product::query()
            ->with(['category', 'images'])
            ->when($request->search, fn($q) =>
                $q->where('name', 'like', "%{$request->search}%")
            )
            ->when($request->category_id, fn($q) =>
                $q->where('category_id', $request->category_id)
            )
            ->when($request->min_price, fn($q) =>
                $q->where('price', '>=', $request->min_price)
            )
            ->latest()
            ->paginate($request->per_page ?? 15);

        return ProductResource::collection($products);
    }

    public function store(StoreProductRequest $request)
    {
        $product = Product::create($request->validated());

        return (new ProductResource($product))
                    ->response()
                    ->setStatusCode(201); // 201 Created
    }

    public function show(int $id)
    {
        $product = Product::with(['category', 'images', 'reviews'])
                          ->findOrFail($id);

        return new ProductResource($product);
    }

    public function update(UpdateProductRequest $request, int $id)
    {
        $product = Product::findOrFail($id);
        $product->update($request->validated());

        return new ProductResource($product);
    }

    public function destroy(int $id)
    {
        $product = Product::findOrFail($id);
        $product->delete();

        return response()->json([
            'message' => 'Product deleted successfully'
        ], 200);
    }
}

Step 5 — Global Exception Handler (সুন্দর Error Response):

php
// app/Exceptions/Handler.php
public function register(): void
{
    $this->renderable(function (Throwable $e, Request $request) {

        if ($request->expectsJson()) {

            // Validation Error
            if ($e instanceof ValidationException) {
                return response()->json([
                    'success' => false,
                    'message' => 'Validation failed',
                    'errors'  => $e->errors(),
                ], 422);
            }

            // Not Found
            if ($e instanceof ModelNotFoundException) {
                return response()->json([
                    'success' => false,
                    'message' => 'Resource not found',
                ], 404);
            }

            // Unauthorized
            if ($e instanceof AuthenticationException) {
                return response()->json([
                    'success' => false,
                    'message' => 'Unauthenticated. Please login first.',
                ], 401);
            }

            // Server Error
            return response()->json([
                'success' => false,
                'message' => 'Something went wrong',
                'debug'   => config('app.debug') ? $e->getMessage() : null,
            ], 500);
        }
    });
}

REST API Response Structure — Best Practice:

json
// ✅ Success Response
{
  "success": true,
  "message": "Products fetched successfully",
  "data": {
    "id": 1,
    "name": "iPhone 15",
    "price": "1,200.00"
  },
  "meta": {
    "total": 150,
    "per_page": 15,
    "current_page": 1
  }
}

// ✅ Error Response
{
  "success": false,
  "message": "Validation failed",
  "errors": {
    "name": ["পণ্যের নাম দিতে হবে"],
    "price": ["দাম দিতে হবে"]
  }
}

🟠 PART 2 — GraphQL API

GraphQL কী এবং কেন REST থেকে আলাদা?

REST এ সমস্যা হলো — Over-fetching (বেশি ডেটা আসে) এবং Under-fetching (কম ডেটা আসে, আবার call করতে হয়)।

❌ REST এর সমস্যা:
GET /api/users/1  → পুরো user object আসে (name, email, phone, address, ...)
                    কিন্তু আমার শুধু name দরকার ছিল!

GET /api/users/1  → user আসে, কিন্তু তার orders নেই
GET /api/users/1/orders → আবার আলাদা call করতে হলো!

✅ GraphQL এর সমাধান:
যা চাইবেন, ঠিক তাই পাবেন — এক request এ!
Laravel-এ GraphQL Setup (Lighthouse):

bash
composer require nuwave/lighthouse
php artisan vendor:publish --tag=lighthouse-schema

Schema Define করুন:

graphql
# graphql/schema.graphql

type Query {
    # Single product
    product(id: ID! @eq): Product @find

    # Product list with filtering & pagination
    products(
        search: String @where(operator: "like", key: "name")
        category_id: ID @eq
        min_price: Float @where(operator: ">=", key: "price")
    ): [Product!]! @paginate(defaultCount: 15)

    # Current logged in user
    me: User @auth
}

type Mutation {
    createProduct(input: CreateProductInput! @spread): Product
        @create
        @middleware(checks: ["auth:sanctum"])

    updateProduct(id: ID!, input: UpdateProductInput! @spread): Product
        @update
        @middleware(checks: ["auth:sanctum"])

    deleteProduct(id: ID!): Product
        @delete
        @middleware(checks: ["auth:sanctum"])
}

# Types
type Product {
    id: ID!
    name: String!
    price: Float!
    stock: Int!
    in_stock: Boolean! @method(name: "isInStock")
    category: Category @belongsTo
    images: [Image!]! @hasMany
    reviews: [Review!]! @hasMany
    created_at: DateTime!
}

type User {
    id: ID!
    name: String!
    email: String!
    orders: [Order!]! @hasMany
}

type Category {
    id: ID!
    name: String!
    products: [Product!]! @hasMany
}

# Input Types
input CreateProductInput {
    name: String!
    price: Float!
    stock: Int!
    category_id: ID!
    description: String
}

input UpdateProductInput {
    name: String
    price: Float
    stock: Int
}

GraphQL Query — Client থেকে এভাবে request করবেন:
graphql
শুধু দরকারি field নিন

query GetProduct {
    product(id: 1) {
        id
        name
        price
        category {
            name
        }
    }
}

ফলাফল — শুধু যা চেয়েছেন তাই আসবে:

{
  "data": {
    "product": {
      "id": "1",
      "name": "iPhone 15",
      "price": 1200.00,
      "category": {
        "name": "Electronics"
      }
    }
  }
}

একসাথে অনেক কিছু নিন — একটাই Request!

query GetDashboard {
    me {
        name
        email
        orders {
            id
            total
            status
        }
    }
    products(category_id: 1) {
        data {
            id
            name
            price
        }
        paginatorInfo {
            total
            currentPage
        }
    }
}

Mutation — Data তৈরি করুন

mutation CreateProduct {
    createProduct(input: {
        name: "Samsung Galaxy S24"
        price: 999.99
        stock: 50
        category_id: 1
    }) {
        id
        name
        price
    }
}

Custom Resolver — Complex Logic এর জন্য:

php
// app/GraphQL/Queries/ProductSearch.php
class ProductSearch
{
    public function __invoke($_, array $args)
    {
        return Product::query()
            ->when(isset($args['search']), fn($q) =>
                $q->where('name', 'like', "%{$args['search']}%")
                  ->orWhere('description', 'like', "%{$args['search']}%")
            )
            ->when(isset($args['min_price']), fn($q) =>
                $q->where('price', '>=', $args['min_price'])
            )
            ->with(['category', 'images'])
            ->get();
    }
}

// app/GraphQL/Mutations/CreateOrder.php
class CreateOrder
{
    public function __invoke($_, array $args)
    {
        // Stock চেক করুন
        $product = Product::lockForUpdate()->findOrFail($args['product_id']);

        if ($product->stock < $args['quantity']) {
            throw new \Exception('Insufficient stock available');
        }

        // Transaction এ Order তৈরি করুন
        return DB::transaction(function () use ($product, $args) {
            $order = Order::create([
                'user_id'    => auth()->id(),
                'product_id' => $product->id,
                'quantity'   => $args['quantity'],
                'total'      => $product->price * $args['quantity'],
            ]);

            $product->decrement('stock', $args['quantity']);

            return $order;
        });
    }
}

🟣 PART 3 — gRPC API

gRPC কী?

gRPC হলো Google এর তৈরি অত্যন্ত দ্রুত API প্রোটোকল। এটা REST এর চেয়ে ৫-১০ গুণ দ্রুত কাজ করে। Microservices এর মধ্যে communication এর জন্য এটা সেরা।

REST  → JSON (Text) → HTTP/1.1   → ধীর, বড় size
gRPC  → Protobuf (Binary) → HTTP/2 → দ্রুত, ছোট size

কখন gRPC ব্যবহার করবেন?
যখন দুটো internal service এর মধ্যে খুব দ্রুত এবং অনেক বেশি communication দরকার — যেমন Order Service থেকে Inventory Service কে প্রতি সেকেন্ডে হাজারবার call করতে হচ্ছে।
Laravel-এ gRPC Setup:

bash
# Protocol Buffer compiler install করুন
pecl install grpc
pecl install protobuf
composer require grpc/grpc

Proto File — API Contract Define করুন:

protobuf
// proto/product.proto
syntax = "proto3";

package product;

// Service Define
service ProductService {
    rpc GetProduct (ProductRequest) returns (ProductResponse);
    rpc GetProducts (ProductsRequest) returns (ProductsResponse);
    rpc CreateProduct (CreateProductRequest) returns (ProductResponse);
    rpc CheckStock (StockRequest) returns (StockResponse);
}

// Messages (REST এ JSON এর মতো)
message ProductRequest {
    int32 id = 1;
}

message ProductResponse {
    int32 id = 1;
    string name = 2;
    double price = 3;
    int32 stock = 4;
    bool in_stock = 5;
}

message StockRequest {
    int32 product_id = 1;
    int32 quantity = 2;
}

message StockResponse {
    bool available = 1;
    int32 current_stock = 2;
    string message = 3;
}

message CreateProductRequest {
    string name = 1;
    double price = 2;
    int32 stock = 3;
    int32 category_id = 4;
}

gRPC Server (Product Service):

php
// app/Grpc/ProductServiceServer.php
class ProductServiceServer extends ProductServiceInterface
{
    // Product খুঁজে দিন
    public function GetProduct(ProductRequest $request, array $metadata = []): array
    {
        $product = Product::find($request->getId());

        if (!$product) {
            return [
                new ProductResponse(),
                Status::status(Code::NOT_FOUND, 'Product not found')
            ];
        }

        $response = new ProductResponse();
        $response->setId($product->id);
        $response->setName($product->name);
        $response->setPrice($product->price);
        $response->setStock($product->stock);
        $response->setInStock($product->stock > 0);

        return [$response, Status::ok()];
    }

    // Stock চেক করুন
    public function CheckStock(StockRequest $request, array $metadata = []): array
    {
        $product = Product::find($request->getProductId());
        $response = new StockResponse();

        if (!$product) {
            $response->setAvailable(false);
            $response->setCurrentStock(0);
            $response->setMessage('Product not found');
        } elseif ($product->stock >= $request->getQuantity()) {
            $response->setAvailable(true);
            $response->setCurrentStock($product->stock);
            $response->setMessage('Stock available');
        } else {
            $response->setAvailable(false);
            $response->setCurrentStock($product->stock);
            $response->setMessage("Only {$product->stock} items available");
        }

        return [$response, Status::ok()];
    }
}

gRPC Client (Order Service থেকে Product Service কে call করা):

php
// app/Services/ProductGrpcClient.php
class ProductGrpcClient
{
    private ProductServiceClient $client;

    public function __construct()
    {
        // Product Service এর address
        $this->client = new ProductServiceClient(
            'product-service:50051', // Internal DNS
            ['credentials' => ChannelCredentials::createInsecure()]
        );
    }

    public function checkStock(int $productId, int $quantity): array
    {
        $request = new StockRequest();
        $request->setProductId($productId);
        $request->setQuantity($quantity);

        [$response, $status] = $this->client->CheckStock($request)->wait();

        if ($status->code !== Code::OK) {
            throw new \Exception('gRPC Error: ' . $status->details);
        }

        return [
            'available'     => $response->getAvailable(),
            'current_stock' => $response->getCurrentStock(),
            'message'       => $response->getMessage(),
        ];
    }
}

// Order Service এ ব্যবহার করুন
class OrderController extends Controller
{
    public function store(Request $request, ProductGrpcClient $productClient)
    {
        // gRPC দিয়ে Product Service কে call — অত্যন্ত দ্রুত!
        $stockInfo = $productClient->checkStock(
            $request->product_id,
            $request->quantity
        );

        if (!$stockInfo['available']) {
            return response()->json([
                'message' => $stockInfo['message']
            ], 422);
        }

        $order = Order::create($request->validated());

        return response()->json($order, 201);
    }
}

⚖️ REST vs GraphQL vs gRPC — কোনটা কখন?

┌─────────────┬──────────────┬──────────────┬──────────────┐
│             │     REST     │   GraphQL    │     gRPC     │
├─────────────┼──────────────┼──────────────┼──────────────┤
│ সেরা ব্যবহার│ Public API   │ Complex UI   │ Microservice │
│             │              │ Mobile App   │ Internal API │
├─────────────┼──────────────┼──────────────┼──────────────┤
│ Speed       │ ⭐⭐⭐        │ ⭐⭐⭐        │ ⭐⭐⭐⭐⭐    │
├─────────────┼──────────────┼──────────────┼──────────────┤
│ শেখা সহজ   │ ✅ সহজ       │ মাঝামাঝি    │ ❌ কঠিন     │
├─────────────┼──────────────┼──────────────┼──────────────┤
│ Flexibility │ কম           │ ✅ অনেক বেশি│ কম          │
├─────────────┼──────────────┼──────────────┼──────────────┤
│ Browser     │ ✅ সরাসরি   │ ✅ সরাসরি   │ ❌ কঠিন     │
│ Support     │              │              │              │
└─────────────┴──────────────┴──────────────┴──────────────┘

Real Project এ কীভাবে ব্যবহার করবেন:

আপনার E-commerce App:

REST API      → Third-party integration, Payment Gateway, Public API
GraphQL       → Mobile App, Web Dashboard (যেখানে flexible data দরকার)
gRPC          → Order Service ↔ Inventory Service (Internal fast communication)

🔐 API Security — সব API তে দরকার

php
// ১. Rate Limiting — প্রতি মিনিটে সর্বোচ্চ কতবার call করা যাবে
RateLimiter::for('api', function (Request $request) {
    return Limit::perMinute(60)->by(
        $request->user()?->id ?: $request->ip()
    );
});

// ২. API Versioning — পুরনো clients ভাঙবে না
Route::prefix('v1')->group(...); // পুরনো version চলবে
Route::prefix('v2')->group(...); // নতুন version আলাদা

// ৩. Request Logging — কে কখন কী করলো
class ApiLoggingMiddleware
{
    public function handle(Request $request, Closure $next)
    {
        $response = $next($request);

        Log::channel('api')->info('API Request', [
            'method'      => $request->method(),
            'url'         => $request->fullUrl(),
            'user_id'     => auth()->id(),
            'ip'          => $request->ip(),
            'status'      => $response->getStatusCode(),
            'duration_ms' => round((microtime(true) - LARAVEL_START) * 1000),
        ]);

        return $response;
    }
}

// ৪. Response Cache — একই request বারবার DB তে না গিয়ে
Route::middleware('cache.headers:public;max_age=3600;etag')->group(function () {
    Route::get('/products', [ProductController::class, 'index']);
});

📝 সংক্ষেপে মনে রাখুন
REST হলো সবচেয়ে সহজ ও জনপ্রিয় — Public API এর জন্য সেরা। GraphQL হলো Flexible — Mobile/Web App এ যখন কতটুকু ডেটা দরকার সেটা Client ঠিক করে। gRPC হলো সবচেয়ে দ্রুত — Microservices এর internal communication এ সেরা।
Laravel Backend Engineer হিসেবে REST অবশ্যই আয়ত্ত করুন, তারপর GraphQL শিখুন, এবং যখন Microservices নিয়ে কাজ করবেন তখন gRPC শিখুন।

Q:3 - Database Systems (SQL, NoSQL) ?
ANSWER:

🗄️ Database কী?
Database হলো ডেটা সংরক্ষণের সিস্টেম। আপনার অ্যাপের সব ডেটা — User, Product, Order — সব কিছু Database এ থাকে।
দুই ধরনের Database আছে:

SQL (Relational)          NoSQL (Non-Relational)
─────────────────         ──────────────────────
MySQL, PostgreSQL    vs   MongoDB, Redis
টেবিল আকারে ডেটা         Document/Key-Value আকারে
Fixed Schema              Flexible Schema
Relations আছে            Relations নেই (বেশিরভাগ)

🔵 PART 1 — SQL Database
SQL কী?
SQL Database এ ডেটা টেবিল আকারে থাকে — অনেকটা Excel Spreadsheet এর মতো। প্রতিটা Row হলো একটা Record, প্রতিটা Column হলো একটা Field।

products টেবিল:
┌────┬─────────────┬────────┬───────┬─────────────┐
│ id │ name        │ price  │ stock │ category_id │
├────┼─────────────┼────────┼───────┼─────────────┤
│  1 │ iPhone 15   │ 1200   │  50   │      1      │
│  2 │ Samsung S24 │  999   │  30   │      1      │
│  3 │ MacBook Pro │ 2500   │  20   │      2      │
└────┴─────────────┴────────┴───────┴─────────────┘

Laravel-এ Database Migration — Professional ভাবে:

php
// database/migrations/create_products_table.php
Schema::create('products', function (Blueprint $table) {

    // Primary Key
    $table->id(); // Auto increment bigint

    // Basic Fields
    $table->string('name', 255);
    $table->string('slug')->unique(); // URL friendly name
    $table->text('description')->nullable();
    $table->decimal('price', 10, 2); // 99999999.99 পর্যন্ত
    $table->decimal('cost_price', 10, 2)->default(0);
    $table->unsignedInteger('stock')->default(0);
    $table->unsignedInteger('min_stock')->default(5); // Low stock alert

    // Status
    $table->enum('status', ['active', 'inactive', 'draft'])->default('active');
    $table->boolean('is_featured')->default(false);

    // Foreign Key — Category এর সাথে সম্পর্ক
    $table->foreignId('category_id')
          ->constrained('categories')
          ->onDelete('restrict'); // Category মুছলে Error দেবে

    $table->foreignId('brand_id')
          ->nullable()
          ->constrained('brands')
          ->onDelete('set null'); // Brand মুছলে NULL হবে

    // Performance এর জন্য Index
    $table->index('status');
    $table->index('category_id');
    $table->index(['price', 'status']); // Composite Index
    $table->fullText(['name', 'description']); // Full-text search

    // Timestamps
    $table->timestamps(); // created_at, updated_at
    $table->softDeletes(); // deleted_at — পুরোপুরি মুছবে না
});

Eloquent Relationships — টেবিলের মধ্যে সম্পর্ক:

php
// ১. One to Many — একটা Category তে অনেক Product
// Category Model
class Category extends Model
{
    public function products(): HasMany
    {
        return $this->hasMany(Product::class);
    }

    // শুধু Active Product
    public function activeProducts(): HasMany
    {
        return $this->hasMany(Product::class)
                    ->where('status', 'active');
    }
}

// ২. Many to Many — একটা Product এ অনেক Tag,
//    একটা Tag এ অনেক Product
class Product extends Model
{
    public function tags(): BelongsToMany
    {
        return $this->belongsToMany(Tag::class, 'product_tags')
                    ->withPivot('added_by') // Pivot table এর extra field
                    ->withTimestamps();
    }
}

// ৩. Has Many Through — User এর Orders এর Products
class User extends Model
{
    public function purchasedProducts(): HasManyThrough
    {
        return $this->hasManyThrough(
            Product::class,
            Order::class,
            'user_id',    // orders.user_id
            'id',         // products.id
            'id',         // users.id
            'product_id'  // orders.product_id
        );
    }
}

// ৪. Polymorphic — Comment একসাথে Product ও Blog এ থাকতে পারে
class Comment extends Model
{
    public function commentable(): MorphTo
    {
        return $this->morphTo();
    }
}

class Product extends Model
{
    public function comments(): MorphMany
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Advanced Eloquent Queries:

php
// ১. Complex Query Builder
$products = Product::query()
    ->select([
        'products.*',
        DB::raw('(SELECT AVG(rating) FROM reviews
                  WHERE reviews.product_id = products.id) as avg_rating'),
        DB::raw('(SELECT COUNT(*) FROM order_items
                  WHERE order_items.product_id = products.id) as total_sold'),
    ])
    ->with(['category:id,name', 'brand:id,name', 'images'])
    ->withCount('reviews')
    ->where('status', 'active')
    ->where('stock', '>', 0)
    ->whereBetween('price', [500, 2000])
    ->whereHas('category', fn($q) => $q->where('is_active', true))
    ->when(request('search'), fn($q, $search) =>
        $q->where(function($query) use ($search) {
            $query->where('name', 'like', "%{$search}%")
                  ->orWhere('description', 'like', "%{$search}%");
        })
    )
    ->orderByDesc('total_sold')
    ->orderByDesc('avg_rating')
    ->paginate(20);

// ২. Subquery — সবচেয়ে বেশি বিক্রি হওয়া Product
$topProducts = Product::addSelect([
    'last_order_date' => Order::select('created_at')
        ->whereColumn('product_id', 'products.id')
        ->latest()
        ->limit(1),
])->get();

// ৩. Aggregation — Sales Report
$salesReport = Order::query()
    ->select([
        DB::raw('DATE(created_at) as date'),
        DB::raw('COUNT(*) as total_orders'),
        DB::raw('SUM(total) as revenue'),
        DB::raw('AVG(total) as avg_order_value'),
        DB::raw('MAX(total) as highest_order'),
    ])
    ->where('status', 'completed')
    ->whereBetween('created_at', [
        now()->startOfMonth(),
        now()->endOfMonth()
    ])
    ->groupBy('date')
    ->orderBy('date')
    ->get();

// ৪. Transaction — একসাথে অনেক কাজ, একটা ব্যর্থ হলে সব Rollback
DB::transaction(function () use ($request) {
    // Order তৈরি করুন
    $order = Order::create([
        'user_id' => auth()->id(),
        'total'   => $request->total,
        'status'  => 'pending',
    ]);

    // প্রতিটা Product এর জন্য OrderItem তৈরি করুন
    foreach ($request->items as $item) {
        // Stock check with lock — Race condition এড়াতে
        $product = Product::lockForUpdate()->findOrFail($item['product_id']);

        if ($product->stock < $item['quantity']) {
            throw new \Exception("{$product->name} এর stock নেই");
        }

        OrderItem::create([
            'order_id'   => $order->id,
            'product_id' => $product->id,
            'quantity'   => $item['quantity'],
            'price'      => $product->price,
        ]);

        // Stock কমিয়ে দিন
        $product->decrement('stock', $item['quantity']);
    }

    // Payment record তৈরি করুন
    Payment::create([
        'order_id' => $order->id,
        'amount'   => $order->total,
        'method'   => $request->payment_method,
    ]);

    return $order;
});

Database Performance — SQL Optimization:

php
// ১. N+1 Query সমস্যা — সবচেয়ে Common ভুল
// ❌ ভুল — ১০০ Product এর জন্য ১০১ টা Query!
$products = Product::all();
foreach ($products as $product) {
    echo $product->category->name; // প্রতিবার DB hit
    echo $product->brand->name;    // আবার DB hit
}

// ✅ সঠিক — মাত্র ৩টা Query
$products = Product::with(['category', 'brand'])->get();

// ২. Lazy Loading vs Eager Loading
// Lazy — শুধু দরকার হলে load হবে (সাবধানে ব্যবহার করুন)
$product = Product::find(1);
if ($showCategory) {
    $product->load('category'); // এখন load হবে
}

// ৩. Chunking — লক্ষ লক্ষ Record Process করুন Memory Overflow ছাড়া
Product::with('category')
       ->where('status', 'active')
       ->chunkById(500, function ($products) {
           foreach ($products as $product) {
               // প্রতি ৫০০টা করে process হবে
               GenerateProductReport::dispatch($product);
           }
       });

// ৪. Cursor — আরো কম Memory তে
foreach (Product::cursor() as $product) {
    // একটা একটা করে process — memory খুব কম লাগে
    $product->update(['slug' => Str::slug($product->name)]);
}

// ৫. Index ব্যবহার করুন — Query দ্রুত হবে
// Migration এ:
$table->index('status');                    // Single index
$table->index(['category_id', 'status']);   // Composite index
$table->index('created_at');               // Date filter এর জন্য

// ৬. Query Cache
$popularProducts = Cache::remember('popular_products', 3600, function () {
    return Product::with('category')
                  ->where('is_featured', true)
                  ->orderByDesc('total_sold')
                  ->take(10)
                  ->get();
});

// Cache clear করুন Product update হলে
Product::observe(ProductObserver::class);

class ProductObserver
{
    public function saved(Product $product): void
    {
        Cache::forget('popular_products');
        Cache::forget("product_{$product->id}");
    }
}

PostgreSQL — MySQL এর চেয়ে শক্তিশালী কোথায়?

php
// ১. JSON Column — Flexible Data Store করুন
Schema::table('products', function (Blueprint $table) {
    $table->jsonb('attributes')->nullable(); // jsonb — indexed & faster
    $table->jsonb('metadata')->nullable();
});

// JSON এ data store করুন
$product->update([
    'attributes' => [
        'color'   => 'Space Black',
        'storage' => '256GB',
        'ram'     => '8GB',
    ]
]);

// JSON field দিয়ে query করুন
$blackPhones = Product::where('attributes->color', 'Space Black')
                       ->where('attributes->storage', '256GB')
                       ->get();

// ২. Full-Text Search — PostgreSQL অনেক ভালো
$products = Product::whereRaw(
    "to_tsvector('english', name || ' ' || description)
     @@ plainto_tsquery('english', ?)",
    [$request->search]
)->get();

// ৩. Window Functions — Advanced Analytics
$rankedProducts = DB::select("
    SELECT
        id, name, price, category_id,
        RANK() OVER (
            PARTITION BY category_id
            ORDER BY price DESC
        ) as price_rank,
        SUM(price) OVER (
            PARTITION BY category_id
        ) as category_total
    FROM products
    WHERE status = 'active'
");

🟠 PART 2 — NoSQL Database

NoSQL কী এবং কেন দরকার?

NoSQL এ ডেটা Document আকারে থাকে — অনেকটা JSON এর মতো। Fixed Schema নেই, যেকোনো Structure এ ডেটা রাখা যায়।

SQL (MySQL):                    NoSQL (MongoDB):
──────────────────              ────────────────────────────
টেবিল → Row → Column           Collection → Document → Field

products টেবিল:                products collection:
id | name | price              {
1  | iPhone | 1200               "_id": "abc123",
                                 "name": "iPhone 15",
                                 "price": 1200,
                                 "variants": [        ← Nested!
                                   {"color": "Black", "stock": 20},
                                   {"color": "White", "stock": 15}
                                 ],
                                 "specs": {           ← Flexible!
                                   "ram": "8GB",
                                   "storage": "256GB"
                                 }
                               }

MongoDB — Laravel Setup:

bashcomposer require mongodb/laravel-mongodb

php
// config/database.php
'mongodb' => [
    'driver'   => 'mongodb',
    'host'     => env('MONGODB_HOST', '127.0.0.1'),
    'port'     => env('MONGODB_PORT', 27017),
    'database' => env('MONGODB_DATABASE', 'myapp'),
    'username' => env('MONGODB_USERNAME', ''),
    'password' => env('MONGODB_PASSWORD', ''),
],

// Model
class Product extends Model
{
    protected $connection = 'mongodb';
    protected $collection = 'products';

    protected $fillable = [
        'name', 'price', 'stock', 'attributes',
        'variants', 'images', 'category'
    ];
}

MongoDB CRUD Operations:

php
// ১. Create — Flexible Structure
$product = Product::create([
    'name'  => 'iPhone 15 Pro',
    'price' => 1299,
    'stock' => 100,

    // Nested Object — SQL এ আলাদা টেবিল লাগতো
    'category' => [
        'id'   => 1,
        'name' => 'Smartphones',
        'slug' => 'smartphones',
    ],

    // Array of Objects — SQL এ Junction Table লাগতো
    'variants' => [
        ['color' => 'Natural Titanium', 'storage' => '128GB', 'stock' => 30, 'price' => 1299],
        ['color' => 'Black Titanium',   'storage' => '256GB', 'stock' => 25, 'price' => 1499],
        ['color' => 'White Titanium',   'storage' => '512GB', 'stock' => 15, 'price' => 1699],
    ],

    // Completely Different Attributes per Product
    'specs' => [
        'chip'    => 'A17 Pro',
        'display' => '6.1 inch Super Retina XDR',
        'camera'  => '48MP Main + 12MP Ultra Wide',
        'battery' => '3274 mAh',
    ],

    'tags'   => ['flagship', 'apple', '5g', 'pro'],
    'images' => [
        ['url' => 'front.jpg', 'is_primary' => true],
        ['url' => 'back.jpg',  'is_primary' => false],
    ],
]);

// ২. Read — Nested Field Query
// Nested field এ search
$blackPhones = Product::where('variants.color', 'Black Titanium')->get();

// Array এ value খুঁজুন
$taggedProducts = Product::where('tags', 'flagship')->get();

// Nested object এ range query
$affordableVariants = Product::where('variants.price', '<=', 1500)->get();

// ৩. Update — Nested Array Update
// Array তে নতুন item যোগ করুন
$product->push('tags', 'bestseller');

// Nested object update করুন
$product->update(['specs.battery' => '3500 mAh']);

// Array থেকে item সরান
$product->pull('tags', 'old-tag');

// ৪. Aggregation Pipeline — Complex Analytics
$categoryStats = Product::raw(function($collection) {
    return $collection->aggregate([
        // Stage 1: Filter
        ['$match' => ['status' => 'active']],

        // Stage 2: Unwind array
        ['$unwind' => '$variants'],

        // Stage 3: Group করুন
        ['$group' => [
            '_id'         => '$category.name',
            'total_products' => ['$sum' => 1],
            'avg_price'   => ['$avg' => '$variants.price'],
            'total_stock' => ['$sum' => '$variants.stock'],
            'min_price'   => ['$min' => '$variants.price'],
            'max_price'   => ['$max' => '$variants.price'],
        ]],

        // Stage 4: Sort
        ['$sort' => ['total_products' => -1]],

        // Stage 5: Limit
        ['$limit' => 10],
    ]);
});

Redis — সবচেয়ে দ্রুত NoSQL:
Redis হলো In-Memory Database — সব ডেটা RAM এ থাকে, তাই অত্যন্ত দ্রুত। এটা মূলত Cache, Session, Queue, এবং Real-time কাজে ব্যবহার হয়।

php
// ১. Simple Cache
// Set — ১ ঘন্টার জন্য cache করুন
Redis::setex('product:1', 3600, json_encode($product));

// Get
$product = json_decode(Redis::get('product:1'));

// Delete
Redis::del('product:1');

// ২. Hash — Object Store করুন
Redis::hmset("user:{$userId}", [
    'name'       => 'রাকিব হাসান',
    'email'      => 'rakib@example.com',
    'last_login' => now()->toDateTimeString(),
    'total_orders' => 25,
]);

// একটা field পড়ুন
$name = Redis::hget("user:{$userId}", 'name');

// সব field পড়ুন
$user = Redis::hgetall("user:{$userId}");

// ৩. Counter — View Count, Like Count
Redis::incr("product:{$productId}:views");
Redis::incrby("product:{$productId}:likes", 1);

$views = Redis::get("product:{$productId}:views");

// ৪. Sorted Set — Leaderboard/Ranking
// Score যোগ করুন
Redis::zadd('product:sales', ['iPhone 15' => 1500, 'Samsung S24' => 1200]);

// Top 10 দেখুন (সবচেয়ে বেশি বিক্রি)
$topSellers = Redis::zrevrange('product:sales', 0, 9, 'WITHSCORES');

// ৫. Pub/Sub — Real-time Notification
// Publisher (Event হলে publish করুন)
Redis::publish('order.created', json_encode([
    'order_id' => $order->id,
    'user_id'  => $order->user_id,
    'total'    => $order->total,
]));

// Subscriber (Background এ চালু থাকবে)
Redis::subscribe(['order.created'], function ($message) {
    $data = json_decode($message);
    // WebSocket দিয়ে User কে notify করুন
    broadcast(new OrderCreatedEvent($data));
});

// ৬. Rate Limiter — Redis দিয়ে
class ApiRateLimiter
{
    public function check(string $key, int $maxAttempts, int $decaySeconds): bool
    {
        $current = Redis::incr($key);

        if ($current === 1) {
            Redis::expire($key, $decaySeconds);
        }

        return $current <= $maxAttempts;
    }
}

// Middleware এ ব্যবহার করুন
if (!$rateLimiter->check("api:{$userId}", 60, 60)) {
    return response()->json(['message' => 'Too many requests'], 429);
}

🔄 PART 3 — SQL vs NoSQL কোনটা কখন?

php
// ✅ SQL ব্যবহার করুন যখন:
// - Data structure fixed এবং সম্পর্ক আছে
// - Financial data (Bank, Payment) — ACID দরকার
// - Complex Joins এবং Transactions দরকার
// - Data Integrity সবচেয়ে গুরুত্বপূর্ণ

// ✅ NoSQL ব্যবহার করুন যখন:
// - Data structure flexible বা unknown
// - Huge scale (লক্ষ লক্ষ record দ্রুত read/write)
// - JSON/Document store করতে হবে
// - Real-time বা Cache দরকার

Real Project এ দুটো একসাথে ব্যবহার:

php
class ProductService
{
    // ১. প্রথমে Redis Cache চেক করুন
    public function getProduct(int $id): array
    {
        $cacheKey = "product:{$id}";

        // Cache এ আছে? → সরাসরি দিন (সবচেয়ে দ্রুত)
        if ($cached = Redis::get($cacheKey)) {
            return json_decode($cached, true);
        }

        // MySQL থেকে নিন → Cache এ রাখুন
        $product = Product::with(['category', 'brand'])->findOrFail($id);
        $productArray = $product->toArray();

        Redis::setex($cacheKey, 3600, json_encode($productArray));

        return $productArray;
    }

    // ২. Product View Track করুন MongoDB তে
    public function trackView(int $productId, string $userId): void
    {
        // MongoDB তে analytics store করুন
        ProductView::create([
            'product_id' => $productId,
            'user_id'    => $userId,
            'ip'         => request()->ip(),
            'user_agent' => request()->userAgent(),
            'viewed_at'  => now(),
            'session'    => [
                'source'   => request()->header('referer'),
                'platform' => $this->detectPlatform(),
            ],
        ]);

        // Redis এ view count বাড়ান
        Redis::incr("product:{$productId}:views");
    }

    // ৩. Search এর জন্য Elasticsearch
    public function search(string $query): Collection
    {
        // Elasticsearch এ full-text search
        $results = Elasticsearch::search([
            'index' => 'products',
            'body'  => [
                'query' => [
                    'multi_match' => [
                        'query'  => $query,
                        'fields' => ['name^3', 'description', 'tags^2'],
                        'fuzziness' => 'AUTO',
                    ]
                ]
            ]
        ]);

        // ID গুলো নিয়ে MySQL থেকে full data আনুন
        $ids = collect($results['hits']['hits'])->pluck('_id');
        return Product::whereIn('id', $ids)->with('category')->get();
    }
}

🏗️ Database Design Best Practices

php
// ১. Naming Convention — সবসময় consistent রাখুন
// টেবিল: plural, snake_case
// products, order_items, product_categories

// Column: singular, snake_case
// user_id, created_at, is_active

// Foreign Key: table_name + _id
// category_id, brand_id, user_id

// ২. Soft Delete — পুরোপুরি মুছবেন না
class Product extends Model
{
    use SoftDeletes; // deleted_at column এ date রাখে

    // Trashed সহ query
    Product::withTrashed()->find(1);

    // শুধু Trashed
    Product::onlyTrashed()->get();

    // Restore করুন
    Product::withTrashed()->find(1)->restore();

    // সত্যিকার Delete
    Product::withTrashed()->find(1)->forceDelete();
}

// ৩. Observer — Model Events Handle করুন
class ProductObserver
{
    public function creating(Product $product): void
    {
        // Auto slug generate করুন
        $product->slug = Str::slug($product->name);
    }

    public function updating(Product $product): void
    {
        // Stock কমলে Alert দিন
        if ($product->isDirty('stock') && $product->stock < $product->min_stock) {
            LowStockAlert::dispatch($product);
        }
    }

    public function deleted(Product $product): void
    {
        // Cache clear করুন
        Cache::forget("product:{$product->id}");
        Cache::forget('popular_products');
    }
}

// ৪. Scope — বারবার একই Query না লিখতে
class Product extends Model
{
    // Global Scope — সবসময় apply হবে
    protected static function booted(): void
    {
        static::addGlobalScope('active', function($query) {
            $query->where('status', 'active');
        });
    }

    // Local Scope — দরকার মতো ব্যবহার করুন
    public function scopeInStock($query)
    {
        return $query->where('stock', '>', 0);
    }

    public function scopeFeatured($query)
    {
        return $query->where('is_featured', true);
    }

    public function scopePriceRange($query, $min, $max)
    {
        return $query->whereBetween('price', [$min, $max]);
    }
}

// ব্যবহার:
$products = Product::inStock()
                   ->featured()
                   ->priceRange(500, 2000)
                   ->get();

📝 সংক্ষেপে মনে রাখুন
SQL (MySQL/PostgreSQL) ব্যবহার করুন যখন ডেটার মধ্যে সম্পর্ক আছে এবং Transactions দরকার — যেমন Orders, Payments, Users। MongoDB ব্যবহার করুন যখন ডেটার Structure flexible — যেমন Products এর Variants, Analytics। Redis ব্যবহার করুন Cache, Session, Queue এবং Real-time এর জন্য — এটা সবচেয়ে দ্রুত।
Real Project এ তিনটাই একসাথে ব্যবহার করা হয় — MySQL মূল ডেটার জন্য, Redis speed এর জন্য, MongoDB flexible data এর জন্য।

Q:4 - Distributed Systems (consistency, replication)
Answer:

🌐 Distributed System কী?
Distributed System হলো এমন একটি সিস্টেম যেখানে একাধিক কম্পিউটার/সার্ভার একসাথে কাজ করে — কিন্তু বাইরে থেকে দেখলে মনে হয় একটাই সিস্টেম।

❌ Single Server (সমস্যা):
[সব User] → [একটা Server] → [একটা Database]
             ↑ এটা crash করলে সব শেষ!

✅ Distributed System (সমাধান):
[User] → [Load Balancer]
              ↓
    ┌─────────┬─────────┐
[Server 1] [Server 2] [Server 3]
    ↓           ↓          ↓
[DB Master] ←──────────────┘
    ↓
[DB Replica 1] [DB Replica 2]

🧩 PART 1 — CAP Theorem
Distributed System এর সবচেয়ে গুরুত্বপূর্ণ Theory
CAP Theorem বলে — একটা Distributed System একসাথে তিনটার মধ্যে মাত্র দুটো গ্যারান্টি দিতে পারে:

C = Consistency    → সব Node এ একই Data দেখাবে
A = Availability   → সবসময় Response পাবেন
P = Partition      → Network ভাগ হলেও সিস্টেম চলবে
  Tolerance

        Consistency (C)
              △
              │
              │
    CA ───────┼──────── CP
              │
              │
              │
    ──────────┼──────────
              │
    AP        │
              │
        Partition (P) ──── Availability (A)

CA — MySQL, PostgreSQL
     (Network Partition হলে বন্ধ হয়ে যায়)

CP — MongoDB, Redis, HBase
     (Partition হলে Availability sacrifice করে)

AP — Cassandra, CouchDB
     (Partition হলে Consistency sacrifice করে)

Real-world উদাহরণ:

php
// ধরুন আপনার E-commerce এ Payment হচ্ছে

// CP System (Bank/Payment) — Consistency বেশি জরুরি
// Network issue হলে → Transaction বন্ধ রাখো
// কারণ: ভুল balance দেখানো মানে বড় সমস্যা

// AP System (Product View Count) — Availability বেশি জরুরি
// Network issue হলে → পুরনো count দেখাও, পরে ঠিক করো
// কারণ: ১০০ এর জায়গায় ৯৮ দেখালে বড় ক্ষতি নেই

🔄 PART 2 — Consistency (সামঞ্জস্যতা)

Consistency Levels — কতটা সঠিক ডেটা দরকার?

Strong Consistency    →  সবচেয়ে নতুন Data — ধীর
Eventual Consistency  →  একটু পুরনো হতে পারে — দ্রুত
Weak Consistency      →  পুরনো Data দিতে পারে — সবচেয়ে দ্রুত

Laravel-এ Consistency Implement করা:
১. Strong Consistency — Critical Data এর জন্য:

php
// Payment বা Financial Transaction — সবসময় Master DB পড়ুন
class PaymentService
{
    public function processPayment(Order $order, array $paymentData): Payment
    {
        return DB::transaction(function () use ($order, $paymentData) {

            // Master DB থেকে পড়ুন — সবচেয়ে নতুন data
            // Replica থেকে নয়! Stale data বিপজ্জনক
            $user = User::lockForUpdate()->findOrFail($order->user_id);
            $wallet = Wallet::lockForUpdate()
                            ->where('user_id', $user->id)
                            ->firstOrFail();

            // Balance চেক করুন
            if ($wallet->balance < $order->total) {
                throw new InsufficientBalanceException(
                    "Balance কম। প্রয়োজন: {$order->total}, আছে: {$wallet->balance}"
                );
            }

            // Balance কাটুন
            $wallet->decrement('balance', $order->total);

            // Payment Record তৈরি করুন
            $payment = Payment::create([
                'order_id'     => $order->id,
                'user_id'      => $user->id,
                'amount'       => $order->total,
                'status'       => 'completed',
                'reference_no' => $this->generateReference(),
            ]);

            // Order Status Update করুন
            $order->update(['status' => 'paid', 'payment_id' => $payment->id]);

            return $payment;
        });
    }
}

// Config — Critical Query সবসময় Master এ
class CriticalController extends Controller
{
    public function sensitiveAction(Request $request)
    {
        // Sticky Session — এই request এর সব query Master এ যাবে
        DB::statement('SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE');

        $result = DB::transaction(function() use ($request) {
            return $this->paymentService->process($request->all());
        });

        return response()->json($result);
    }
}

২. Eventual Consistency — Non-critical Data এর জন্য:

php
// Product View Count — একটু পুরনো হলেও সমস্যা নেই
class ProductViewController
{
    public function track(int $productId): void
    {
        // Redis এ দ্রুত increment করুন (Eventual)
        // Database এ সাথে সাথে না গিয়ে পরে Sync হবে
        Redis::incr("product:{$productId}:views");
        Redis::expire("product:{$productId}:views", 86400);

        // Queue এ Job দিন — পরে DB Sync হবে
        SyncProductViews::dispatch($productId)
                        ->delay(now()->addMinutes(5));
    }
}

// Background Job — Redis থেকে DB তে Sync
class SyncProductViews implements ShouldQueue
{
    public function __construct(private int $productId) {}

    public function handle(): void
    {
        $views = Redis::get("product:{$this->productId}:views") ?? 0;

        Product::where('id', $this->productId)
               ->update(['view_count' => DB::raw("view_count + {$views}")]);

        // Redis reset করুন
        Redis::del("product:{$this->productId}:views");
    }
}

৩. Read-Your-Writes Consistency:

php
// Problem: User profile update করলো,
// কিন্তু Replica থেকে পুরনো data দেখাচ্ছে!

class UserProfileService
{
    public function updateProfile(User $user, array $data): User
    {
        // Master এ update করুন
        $user->update($data);

        // Session এ flag রাখুন — এই user সবে update করেছে
        session(['read_from_master_until' => now()->addSeconds(5)]);

        return $user;
    }

    public function getProfile(int $userId): User
    {
        // Update করার পর ৫ সেকেন্ড Master থেকে পড়ুন
        if (session('read_from_master_until') > now()) {
            return DB::connection('mysql_master')
                     ->table('users')
                     ->where('id', $userId)
                     ->first();
        }

        // তারপর Replica থেকে পড়ুন (দ্রুত)
        return User::find($userId);
    }
}

📋 PART 3 — Replication (প্রতিলিপি)

Replication কী?

একই ডেটা একাধিক সার্ভারে রাখা — যাতে একটা বন্ধ হলেও বাকিগুলো চলে।

Master-Slave Replication:

[Write] → [Master DB] ──→ [Slave/Replica 1] ← [Read]
                      └──→ [Slave/Replica 2] ← [Read]
                      └──→ [Slave/Replica 3] ← [Read]

Master: শুধু Write
Slave:  শুধু Read (অনেক বেশি Read Traffic সামলাতে পারে)

Laravel-এ Master-Slave Replication:

php
// config/database.php
'mysql' => [
    'driver' => 'mysql',

    // Write — সব INSERT, UPDATE, DELETE এখানে যাবে
    'write' => [
        'host' => env('DB_MASTER_HOST', '10.0.0.1'),
        'port' => env('DB_MASTER_PORT', 3306),
    ],

    // Read — সব SELECT এখানে যাবে (Load Balance হবে)
    'read' => [
        ['host' => env('DB_REPLICA_1_HOST', '10.0.0.2')],
        ['host' => env('DB_REPLICA_2_HOST', '10.0.0.3')],
        ['host' => env('DB_REPLICA_3_HOST', '10.0.0.4')],
    ],

    'sticky'   => true, // Write এর পর সাথে সাথে Read করলে Master থেকে পড়বে
    'database' => env('DB_DATABASE'),
    'username' => env('DB_USERNAME'),
    'password' => env('DB_PASSWORD'),
],

// আলাদা Connection — Critical Read এর জন্য
'mysql_master' => [
    'driver'   => 'mysql',
    'host'     => env('DB_MASTER_HOST'),
    'database' => env('DB_DATABASE'),
    'username' => env('DB_USERNAME'),
    'password' => env('DB_PASSWORD'),
],

Replication Lag Handle করা:

php
// Problem: Master এ write করলাম,
// কিন্তু Replica তে এখনো পৌঁছায়নি!
// এই সময়কে বলে Replication Lag

class OrderService
{
    public function createOrder(array $data): Order
    {
        // Master এ Order তৈরি করুন
        $order = Order::create($data);

        // Replication Lag এড়াতে — ID Cache এ রাখুন
        Cache::put(
            "order_exists:{$order->id}",
            true,
            now()->addSeconds(10) // ১০ সেকেন্ড — Lag এর চেয়ে বেশি
        );

        return $order;
    }

    public function getOrder(int $orderId): Order
    {
        // সবে তৈরি হয়েছে? Master থেকে পড়ুন
        if (Cache::has("order_exists:{$orderId}")) {
            return DB::connection('mysql_master')
                     ->table('orders')
                     ->where('id', $orderId)
                     ->first();
        }

        // পুরনো Order — Replica থেকে পড়ুন
        return Order::find($orderId);
    }
}

🔀 PART 4 — Sharding (ডেটা ভাগ করা)

Sharding কী?

যখন একটা DB Server এ ডেটা অনেক বেশি হয়ে যায়, তখন ডেটাকে ভাগ করে একাধিক সার্ভারে রাখা হয়।

Without Sharding:
[১ কোটি User] → [একটা DB] ← অনেক Slow!

With Sharding:
User ID 1-25 লক্ষ    → [DB Shard 1]
User ID 25-50 লক্ষ   → [DB Shard 2]
User ID 50-75 লক্ষ   → [DB Shard 3]
User ID 75-100 লক্ষ  → [DB Shard 4]

Laravel-এ Sharding Implement করা:

php
// app/Services/ShardingService.php
class ShardingService
{
    // Shard গুলোর Connection name
    private array $shards = [
        'db_shard_1',
        'db_shard_2',
        'db_shard_3',
        'db_shard_4',
    ];

    // User ID দিয়ে কোন Shard এ যাবে নির্ধারণ করুন
    public function getShardForUser(int $userId): string
    {
        $shardIndex = $userId % count($this->shards);
        return $this->shards[$shardIndex];
    }

    // Geographic Sharding — দেশ অনুযায়ী
    public function getShardForCountry(string $countryCode): string
    {
        return match(true) {
            in_array($countryCode, ['BD', 'IN', 'PK']) => 'db_shard_asia',
            in_array($countryCode, ['US', 'CA'])       => 'db_shard_na',
            in_array($countryCode, ['GB', 'DE', 'FR']) => 'db_shard_eu',
            default                                    => 'db_shard_global',
        };
    }
}

// Sharded User Repository
class ShardedUserRepository
{
    public function __construct(
        private ShardingService $sharding
    ) {}

    public function find(int $userId): ?object
    {
        $shard = $this->sharding->getShardForUser($userId);

        return DB::connection($shard)
                 ->table('users')
                 ->where('id', $userId)
                 ->first();
    }

    public function create(array $data): object
    {
        // User তৈরি করুন — ID আগে জানি না
        // তাই সব Shard এ sequentially try করুন
        $userId = $this->generateUserId();
        $shard  = $this->sharding->getShardForUser($userId);

        DB::connection($shard)->table('users')->insert([
            'id'         => $userId,
            'name'       => $data['name'],
            'email'      => $data['email'],
            'created_at' => now(),
        ]);

        return $this->find($userId);
    }

    // Cross-Shard Query — সব Shard এ Search করুন
    public function searchByEmail(string $email): ?object
    {
        foreach ($this->sharding->getAllShards() as $shard) {
            $user = DB::connection($shard)
                      ->table('users')
                      ->where('email', $email)
                      ->first();

            if ($user) return $user;
        }

        return null;
    }

    // Parallel Cross-Shard Query — দ্রুত Version
    public function searchAllShards(string $query): Collection
    {
        $results = collect();
        $jobs    = [];

        // সব Shard এ একসাথে Query পাঠান
        foreach ($this->sharding->getAllShards() as $shard) {
            $jobs[] = SearchShard::dispatch($shard, $query);
        }

        // Result collect করুন
        // (Real implementation এ Promise/Async ব্যবহার করুন)
        return $results;
    }
}

🔒 PART 5 — Distributed Locking

সমস্যা — Race Condition:

দুজন User একসাথে শেষ ১টা Product কিনতে চাইছে:

User A: Stock Check → ১ আছে ✓
User B: Stock Check → ১ আছে ✓  ← একই সময়ে!
User A: Order Create → Stock 0
User B: Order Create → Stock -1  ← বিপদ!

Solution — Distributed Lock দিয়ে:

php
// app/Services/DistributedLockService.php
class DistributedLockService
{
    private Redis $redis;
    private string $lockPrefix = 'lock:';

    // Lock নিন
    public function acquire(
        string $resource,
        int $ttlSeconds = 30
    ): ?string {
        $lockKey   = $this->lockPrefix . $resource;
        $lockToken = Str::uuid()->toString(); // Unique token

        // SET NX — শুধু তখনই set হবে যদি না থাকে
        $acquired = Redis::set(
            $lockKey,
            $lockToken,
            'EX', $ttlSeconds,  // TTL
            'NX'                // Only if Not Exists
        );

        return $acquired ? $lockToken : null;
    }

    // Lock ছাড়ুন — শুধু যে নিয়েছে সেই ছাড়তে পারবে
    public function release(string $resource, string $token): bool
    {
        $lockKey = $this->lockPrefix . $resource;

        // Lua Script — Atomic operation
        $script = "
            if redis.call('get', KEYS[1]) == ARGV[1] then
                return redis.call('del', KEYS[1])
            else
                return 0
            end
        ";

        return (bool) Redis::eval($script, 1, $lockKey, $token);
    }

    // Lock সহ কাজ করুন — Automatic release
    public function withLock(
        string $resource,
        callable $callback,
        int $ttl = 30
    ): mixed {
        $token = $this->acquire($resource, $ttl);

        if (!$token) {
            throw new LockNotAcquiredException(
                "Resource '{$resource}' is currently locked. Please try again."
            );
        }

        try {
            return $callback();
        } finally {
            $this->release($resource, $token);
        }
    }
}

// ব্যবহার — Product Purchase এ
class PurchaseController extends Controller
{
    public function __construct(
        private DistributedLockService $lockService,
        private OrderService $orderService
    ) {}

    public function purchase(Request $request)
    {
        $productId = $request->product_id;

        try {
            // Product এর জন্য Lock নিন
            $result = $this->lockService->withLock(
                "product:purchase:{$productId}",
                function () use ($request, $productId) {

                    // Lock এর ভেতরে — এখন একজনই আছে
                    $product = Product::lockForUpdate()
                                      ->findOrFail($productId);

                    if ($product->stock < $request->quantity) {
                        throw new InsufficientStockException(
                            "মাত্র {$product->stock}টা বাকি আছে"
                        );
                    }

                    return $this->orderService->create([
                        'product_id' => $productId,
                        'quantity'   => $request->quantity,
                        'user_id'    => auth()->id(),
                    ]);
                },
                ttl: 10 // ১০ সেকেন্ডের মধ্যে শেষ করতে হবে
            );

            return response()->json([
                'success' => true,
                'order'   => $result,
            ]);

        } catch (LockNotAcquiredException $e) {
            return response()->json([
                'success' => false,
                'message' => 'এই মুহূর্তে অনেক চাপ। একটু পরে try করুন।',
            ], 429);

        } catch (InsufficientStockException $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }
}

📨 PART 6 — Distributed Message Queue

Queue কেন দরকার Distributed System এ?

সমস্যা — Services সরাসরি কথা বললে:
[Order Service] → HTTP → [Email Service]
                          ↑ যদি down থাকে?
                          → Order fail হয়ে যাবে!

সমাধান — Queue দিয়ে:
[Order Service] → [Queue] → [Email Service]
                   ↑ Email Service down হলেও
                   Queue এ থাকবে, পরে পাঠাবে

php
// app/Jobs/ProcessOrderJob.php
class ProcessOrderJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    // Retry Configuration
    public int $tries   = 3;     // ৩ বার try করবে
    public int $timeout = 60;    // ৬০ সেকেন্ডের বেশি না
    public int $backoff = 5;     // Retry এর আগে ৫ সেকেন্ড অপেক্ষা

    public function __construct(
        private Order $order
    ) {}

    public function handle(
        EmailService $emailService,
        InventoryService $inventoryService,
        NotificationService $notificationService
    ): void {
        // ১. Inventory Update করুন
        $inventoryService->reduceStock(
            $this->order->product_id,
            $this->order->quantity
        );

        // ২. Email পাঠান
        $emailService->sendOrderConfirmation($this->order);

        // ৩. Push Notification পাঠান
        $notificationService->notify(
            $this->order->user_id,
            "আপনার Order #{$this->order->id} confirmed!"
        );

        // ৪. Analytics Update করুন
        SyncOrderAnalytics::dispatch($this->order)
                          ->onQueue('analytics') // আলাদা Queue
                          ->delay(now()->addMinutes(1));
    }

    // সব Retry ব্যর্থ হলে
    public function failed(\Throwable $exception): void
    {
        Log::error('Order processing failed', [
            'order_id' => $this->order->id,
            'error'    => $exception->getMessage(),
        ]);

        // Admin কে Alert করুন
        AdminAlert::dispatch(
            "Order #{$this->order->id} processing failed!",
            $exception->getMessage()
        );

        // Order Status Update করুন
        $this->order->update(['status' => 'processing_failed']);
    }
}

// Priority Queue — জরুরি কাজ আগে
class OrderController extends Controller
{
    public function store(Request $request)
    {
        $order = Order::create($request->validated());

        // High Priority — দ্রুত process হবে
        ProcessOrderJob::dispatch($order)
                       ->onQueue('high-priority');

        // Normal Priority
        GenerateInvoice::dispatch($order)
                       ->onQueue('default');

        // Low Priority — পরে হলেও চলবে
        UpdateRecommendations::dispatch($order)
                              ->onQueue('low-priority');

        return response()->json($order, 201);
    }
}

// Queue Worker চালান — আলাদা আলাদা Priority
// php artisan queue:work --queue=high-priority,default,low-priority

🏥 PART 7 — Health Check & Fault Tolerance

php
// app/Http/Controllers/HealthController.php
class HealthController extends Controller
{
    public function check(): JsonResponse
    {
        $checks = [
            'database'   => $this->checkDatabase(),
            'redis'      => $this->checkRedis(),
            'queue'      => $this->checkQueue(),
            'disk'       => $this->checkDisk(),
        ];

        $allHealthy = collect($checks)->every(
            fn($check) => $check['status'] === 'healthy'
        );

        return response()->json([
            'status'    => $allHealthy ? 'healthy' : 'degraded',
            'timestamp' => now()->toIso8601String(),
            'services'  => $checks,
        ], $allHealthy ? 200 : 503);
    }

    private function checkDatabase(): array
    {
        try {
            $start = microtime(true);
            DB::select('SELECT 1');
            $responseTime = round((microtime(true) - $start) * 1000, 2);

            return [
                'status'        => 'healthy',
                'response_time' => "{$responseTime}ms",
            ];
        } catch (\Exception $e) {
            return ['status' => 'unhealthy', 'error' => $e->getMessage()];
        }
    }

    private function checkRedis(): array
    {
        try {
            $start = microtime(true);
            Redis::ping();
            $responseTime = round((microtime(true) - $start) * 1000, 2);

            return [
                'status'        => 'healthy',
                'response_time' => "{$responseTime}ms",
            ];
        } catch (\Exception $e) {
            return ['status' => 'unhealthy', 'error' => $e->getMessage()];
        }
    }

    private function checkQueue(): array
    {
        $failedJobs = DB::table('failed_jobs')->count();

        return [
            'status'      => $failedJobs < 10 ? 'healthy' : 'degraded',
            'failed_jobs' => $failedJobs,
        ];
    }

    private function checkDisk(): array
    {
        $freeSpace  = disk_free_space('/');
        $totalSpace = disk_total_space('/');
        $usedPercent = round((1 - $freeSpace / $totalSpace) * 100, 1);

        return [
            'status'       => $usedPercent < 85 ? 'healthy' : 'critical',
            'used_percent' => "{$usedPercent}%",
            'free_space'   => $this->formatBytes($freeSpace),
        ];
    }
}

// Circuit Breaker — Service বার বার fail করলে বন্ধ করুন
class CircuitBreaker
{
    private string $service;
    private int    $threshold;  // কতবার fail হলে open হবে
    private int    $timeout;    // কতক্ষণ open থাকবে

    // States: closed (normal), open (blocked), half-open (testing)
    public function call(callable $action): mixed
    {
        $state = $this->getState();

        // Open — Service বন্ধ, সরাসরি Error দিন
        if ($state === 'open') {
            if ($this->shouldAttemptReset()) {
                $this->setState('half-open');
            } else {
                throw new ServiceUnavailableException(
                    "{$this->service} is currently unavailable"
                );
            }
        }

        try {
            $result = $action();
            $this->onSuccess(); // Closed State এ ফিরুন
            return $result;

        } catch (\Exception $e) {
            $this->onFailure(); // Failure Count বাড়ান
            throw $e;
        }
    }

    private function onSuccess(): void
    {
        Redis::del("circuit:{$this->service}:failures");
        $this->setState('closed');
    }

    private function onFailure(): void
    {
        $failures = Redis::incr("circuit:{$this->service}:failures");
        Redis::expire("circuit:{$this->service}:failures", $this->timeout);

        if ($failures >= $this->threshold) {
            $this->setState('open');
            Log::warning("Circuit Breaker opened for {$this->service}");
        }
    }

    private function getState(): string
    {
        return Redis::get("circuit:{$this->service}:state") ?? 'closed';
    }

    private function setState(string $state): void
    {
        Redis::setex(
            "circuit:{$this->service}:state",
            $this->timeout,
            $state
        );
    }
}

// ব্যবহার
class ExternalApiService
{
    public function __construct(
        private CircuitBreaker $breaker
    ) {}

    public function getData(): array
    {
        return $this->breaker->call(function () {
            $response = Http::timeout(5)
                            ->get('https://external-api.com/data');

            if ($response->failed()) {
                throw new \Exception('API call failed');
            }

            return $response->json();
        });
    }
}

📝 সংক্ষেপে মনে রাখুন
Distributed Systems এর মূল বিষয়গুলো হলো —
CAP Theorem — Consistency, Availability, Partition Tolerance — যেকোনো দুটো বেছে নিতে হবে।
Consistency — Critical data (Payment) তে Strong, Non-critical (View Count) তে Eventual।
Replication — Master Write করে, Replica Read করে — Performance ও Availability দুটোই বাড়ে।
Sharding — ডেটা অনেক বেশি হলে ভাগ করে রাখুন।
Distributed Lock — Race Condition এড়াতে Redis Lock ব্যবহার করুন।
Circuit Breaker — একটা Service বারবার fail করলে বাকি সিস্টেম রক্ষা করুন।

Laravel এ Redis, Queue, Database Read/Write Split ব্যবহার করে এই সব Concept সহজেই Implement করা যায়।

Q:5 - Caching (Redis, Memcached)
Answer:

⚡ Caching কী?
Caching হলো ঘন ঘন ব্যবহৃত ডেটা দ্রুত অ্যাক্সেসের জন্য কাছে রেখে দেওয়া। প্রতিবার Database এ না গিয়ে Cache থেকে ডেটা নিলে সিস্টেম অনেক দ্রুত হয়।

❌ Without Cache:
[User Request] → [Laravel] → [Database] → [Response]
                              ↑ প্রতিবার DB Hit = ধীর, ব্যয়বহুল

✅ With Cache:
[User Request] → [Laravel] → [Cache] → [Response]  ← দ্রুত!
                                ↓ না থাকলে
                           [Database] → [Cache তে রাখো] → [Response]

Cache কতটা দ্রুত?

Database Query  →  10-100ms
Redis Cache     →  0.1-1ms   ← ১০০ গুণ দ্রুত!
Memcached       →  0.1-1ms   ← ১০০ গুণ দ্রুত!
Memory (Array)  →  0.001ms   ← সবচেয়ে দ্রুত কিন্তু Persistent না

🔧 PART 1 — Laravel Cache Setup
Redis Setup:

bash
# Redis Install করুন
composer require predis/predis
# অথবা PHP Redis Extension
pecl install redis

php
// .env
CACHE_DRIVER=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379
REDIS_DB=0           // Cache এর জন্য
REDIS_CACHE_DB=1     // আলাদা DB — Session এর সাথে মিশবে না

// config/cache.php
'redis' => [
    'driver'     => 'redis',
    'connection' => 'cache',
    'lock_connection' => 'default',
],

// config/database.php — Redis Connections
'redis' => [
    'default' => [
        'host'     => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD', null),
        'port'     => env('REDIS_PORT', 6379),
        'database' => 0, // Queue & General
    ],
    'cache' => [
        'host'     => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD', null),
        'port'     => env('REDIS_PORT', 6379),
        'database' => 1, // Cache আলাদা DB তে
    ],
    'session' => [
        'host'     => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD', null),
        'port'     => env('REDIS_PORT', 6379),
        'database' => 2, // Session আলাদা DB তে
    ],
],

Memcached Setup:

bashcomposer require ext-memcached

php
// .env
CACHE_DRIVER=memcached
MEMCACHED_HOST=127.0.0.1
MEMCACHED_PORT=11211

// config/cache.php
'memcached' => [
    'driver'  => 'memcached',
    'servers' => [
        [
            'host'   => env('MEMCACHED_HOST', '127.0.0.1'),
            'port'   => env('MEMCACHED_PORT', 11211),
            'weight' => 100,
        ],
        // Multiple Servers — Load Distribution
        [
            'host'   => env('MEMCACHED_HOST_2', '10.0.0.2'),
            'port'   => 11211,
            'weight' => 100,
        ],
    ],
],

🎯 PART 2 — Cache Strategies (কৌশল)
Strategy 1 — Cache-Aside (Lazy Loading)
সবচেয়ে জনপ্রিয় Pattern। দরকার হলে Cache এ রাখা হয়।

php
// app/Services/ProductService.php
class ProductService
{
    // ১. Basic Cache Remember
    public function getProduct(int $id): Product
    {
        return Cache::remember(
            "product:{$id}",          // Cache Key
            now()->addHours(6),       // Expiry — ৬ ঘন্টা
            fn() => Product::with(['category', 'brand', 'images'])
                            ->findOrFail($id)
        );
    }

    // ২. Cache Forever — খুব কম পরিবর্তন হয় এমন Data
    public function getCategories(): Collection
    {
        return Cache::rememberForever(
            'all_categories',
            fn() => Category::where('is_active', true)
                            ->orderBy('name')
                            ->get()
        );
    }

    // ৩. Cache Tags — Related Cache একসাথে Clear করুন
    public function getProductsByCategory(int $categoryId): Collection
    {
        return Cache::tags(['products', "category:{$categoryId}"])
                    ->remember(
                        "products:category:{$categoryId}",
                        now()->addHours(2),
                        fn() => Product::where('category_id', $categoryId)
                                       ->where('status', 'active')
                                       ->with(['brand', 'images'])
                                       ->orderByDesc('created_at')
                                       ->get()
                    );
    }

    // ৪. Stale-While-Revalidate — Cache Expire হলেও পুরনো দেখাও
    //    Background এ নতুন করো
    public function getPopularProducts(): Collection
    {
        $cacheKey = 'popular_products';

        // Cache আছে? → দিন
        if ($cached = Cache::get($cacheKey)) {

            // Cache প্রায় শেষ? → Background এ refresh করুন
            $ttl = Cache::get("{$cacheKey}:ttl");
            if ($ttl && $ttl < now()->addMinutes(5)->timestamp) {
                RefreshPopularProductsCache::dispatch();
            }

            return $cached;
        }

        // Cache নেই → DB থেকে নিন
        return $this->refreshPopularProductsCache();
    }

    public function refreshPopularProductsCache(): Collection
    {
        $products = Product::withCount('orders')
                           ->orderByDesc('orders_count')
                           ->take(20)
                           ->get();

        Cache::put('popular_products', $products, now()->addHour());
        Cache::put('popular_products:ttl', now()->addHour()->timestamp, now()->addHour());

        return $products;
    }
}

Strategy 2 — Write-Through Cache
Data লেখার সময় একসাথে Cache ও Database Update করা।

php
class ProductRepository
{
    // Create — DB ও Cache একসাথে
    public function create(array $data): Product
    {
        $product = Product::create($data);

        // সাথে সাথে Cache এ রাখুন
        Cache::put(
            "product:{$product->id}",
            $product->load(['category', 'brand']),
            now()->addHours(6)
        );

        // Category Cache Clear করুন
        Cache::tags(["category:{$product->category_id}"])->flush();
        Cache::forget('popular_products');

        return $product;
    }

    // Update — DB ও Cache একসাথে
    public function update(int $id, array $data): Product
    {
        $product = Product::findOrFail($id);
        $oldCategoryId = $product->category_id;

        $product->update($data);
        $product->refresh()->load(['category', 'brand', 'images']);

        // Cache Update করুন
        Cache::put("product:{$id}", $product, now()->addHours(6));

        // Related Cache Clear করুন
        Cache::tags(["category:{$oldCategoryId}"])->flush();

        if ($product->category_id !== $oldCategoryId) {
            Cache::tags(["category:{$product->category_id}"])->flush();
        }

        return $product;
    }

    // Delete — DB ও Cache একসাথে
    public function delete(int $id): bool
    {
        $product = Product::findOrFail($id);

        // Cache গুলো Clear করুন
        Cache::forget("product:{$id}");
        Cache::tags(["category:{$product->category_id}", 'products'])->flush();

        return $product->delete();
    }
}

Strategy 3 — Write-Behind Cache (Lazy Write)
Cache এ লিখুন — Database এ পরে Sync করুন। অনেক দ্রুত।

php
// Counter বা Analytics এর জন্য দারুণ
class AnalyticsService
{
    // ১. View Count — Cache এ রাখুন, পরে DB Sync
    public function incrementView(int $productId): void
    {
        $key = "product:{$productId}:views:pending";

        // Redis এ Increment করুন — DB তে যাবে না এখন
        Redis::incr($key);
        Redis::expire($key, 3600);

        // ৫ মিনিট পর DB Sync করুন
        SyncViewCount::dispatch($productId)
                     ->delay(now()->addMinutes(5))
                     ->onQueue('analytics');
    }

    // ২. Like/Dislike — Batch এ DB তে লিখুন
    public function toggleLike(int $productId, int $userId): array
    {
        $likeKey    = "product:{$productId}:likes";
        $dislikeKey = "product:{$productId}:dislikes";
        $userLikeKey = "user:{$userId}:liked_products";

        // User আগে Like দিয়েছে?
        $hasLiked = Redis::sismember($userLikeKey, $productId);

        if ($hasLiked) {
            // Unlike করুন
            Redis::srem($userLikeKey, $productId);
            Redis::decr($likeKey);
            $action = 'unliked';
        } else {
            // Like করুন
            Redis::sadd($userLikeKey, $productId);
            Redis::incr($likeKey);
            $action = 'liked';
        }

        // Background এ DB Sync করুন
        SyncProductLikes::dispatch($productId, $userId, $action)
                        ->onQueue('analytics');

        return [
            'action' => $action,
            'likes'  => (int) Redis::get($likeKey),
        ];
    }
}

// Background Sync Job
class SyncViewCount implements ShouldQueue
{
    public function __construct(private int $productId) {}

    public function handle(): void
    {
        $key   = "product:{$this->productId}:views:pending";
        $views = Redis::getdel($key); // Get and Delete atomically

        if ($views) {
            Product::where('id', $this->productId)
                   ->increment('view_count', (int) $views);
        }
    }
}

🏗️ PART 3 — Cache Key Design (গুরুত্বপূর্ণ!)

php
// app/Services/CacheKeyService.php
class CacheKey
{
    // ভালো Cache Key Design — Hierarchical
    const VERSION = 'v1'; // Schema change হলে version বাড়ান

    // Product Keys
    public static function product(int $id): string
    {
        return self::VERSION . ":product:{$id}";
    }

    public static function productList(array $filters = []): string
    {
        $filterHash = md5(serialize($filters)); // Filters এর Hash
        return self::VERSION . ":products:list:{$filterHash}";
    }

    public static function productsByCategory(int $catId, int $page = 1): string
    {
        return self::VERSION . ":products:cat:{$catId}:page:{$page}";
    }

    // User Keys
    public static function userProfile(int $userId): string
    {
        return self::VERSION . ":user:{$userId}:profile";
    }

    public static function userCart(int $userId): string
    {
        return self::VERSION . ":user:{$userId}:cart";
    }

    public static function userPermissions(int $userId): string
    {
        return self::VERSION . ":user:{$userId}:permissions";
    }

    // Config Keys
    public static function siteSettings(): string
    {
        return self::VERSION . ":config:site_settings";
    }
}

// ব্যবহার
Cache::remember(CacheKey::product($id), 3600, fn() => Product::find($id));
Cache::remember(CacheKey::userCart($userId), 1800, fn() => Cart::forUser($userId));

// ❌ ভুল Cache Key Design
Cache::remember('product', ...);          // Collision!
Cache::remember("product_$id", ...);      // Version নেই
Cache::remember("p_{$id}", ...);          // বোঝা যাচ্ছে না

🔴 PART 4 — Redis Advanced Features
Redis Data Structures — Laravel এ:

php
// ১. String — Simple Value Store
Redis::set('app:version', '2.5.1');
Redis::setex('otp:01712345678', 300, '123456'); // ৫ মিনিট
$otp = Redis::get('otp:01712345678');

// ২. Hash — Object Store (User Session এর মতো)
Redis::hmset("cart:{$userId}", [
    'items_count' => 5,
    'total'       => 2500,
    'coupon'      => 'SAVE20',
    'updated_at'  => now()->timestamp,
]);

// একটা field update
Redis::hset("cart:{$userId}", 'items_count', 6);

// সব field পড়ুন
$cart = Redis::hgetall("cart:{$userId}");

// ৩. List — Queue / Recent Items
// Left Push — নতুন item সামনে
Redis::lpush("user:{$userId}:recent_products", $productId);

// List এর size limit — শুধু ১০টা রাখুন
Redis::ltrim("user:{$userId}:recent_products", 0, 9);

// সব recent products
$recentProducts = Redis::lrange("user:{$userId}:recent_products", 0, -1);

// ৪. Set — Unique Values (Tags, Followers)
// Product Tags
Redis::sadd("product:{$productId}:tags", 'smartphone', 'apple', '5g');

// User Wishlist
Redis::sadd("user:{$userId}:wishlist", $productId);
Redis::srem("user:{$userId}:wishlist", $productId); // Remove

// Wishlist এ আছে?
$inWishlist = Redis::sismember("user:{$userId}:wishlist", $productId);

// Common Products (Intersection) — দুজনের Common Wishlist
$commonWishlist = Redis::sinter(
    "user:{$user1Id}:wishlist",
    "user:{$user2Id}:wishlist"
);

// ৫. Sorted Set — Leaderboard / Ranking
// Sales Score যোগ করুন
Redis::zadd('leaderboard:products:weekly', [
    'iPhone 15'   => 1500,
    'Samsung S24' => 1200,
    'MacBook Pro' => 800,
]);

// Score বাড়ান
Redis::zincrby('leaderboard:products:weekly', 10, 'iPhone 15');

// Top 10 Products
$topProducts = Redis::zrevrange(
    'leaderboard:products:weekly',
    0, 9,
    'WITHSCORES'
);

// Rank জানুন
$rank = Redis::zrevrank('leaderboard:products:weekly', 'iPhone 15');

// ৬. HyperLogLog — Unique Visitor Count (Memory দক্ষ)
// প্রতিটা Visitor এর IP যোগ করুন
Redis::pfadd("page:{$pageId}:visitors:today", $request->ip());

// Approximate unique count (৯৯.৫% accurate, মাত্র ১২KB memory!)
$uniqueVisitors = Redis::pfcount("page:{$pageId}:visitors:today");

// ৭. Pub/Sub — Real-time Notification
// Publisher
Redis::publish('notifications', json_encode([
    'user_id' => $userId,
    'message' => 'আপনার Order Confirm হয়েছে!',
    'type'    => 'order_confirmed',
]));

// Subscriber (Artisan Command হিসেবে চালান)
Redis::subscribe(['notifications'], function ($message) {
    $data = json_decode($message, true);
    // WebSocket দিয়ে User কে পাঠান
    broadcast(new UserNotification($data));
});

Redis Pipeline — Multiple Commands একসাথে:

php
// ❌ ধীর — প্রতিটা Command আলাদা Network Trip
Redis::set('key1', 'value1');
Redis::set('key2', 'value2');
Redis::set('key3', 'value3');
Redis::expire('key1', 3600);
Redis::expire('key2', 3600);

// ✅ দ্রুত — একটাই Network Trip এ সব
Redis::pipeline(function ($pipe) {
    $pipe->set('key1', 'value1');
    $pipe->set('key2', 'value2');
    $pipe->set('key3', 'value3');
    $pipe->expire('key1', 3600);
    $pipe->expire('key2', 3600);
});

// Real Example — User Login Cache
public function cacheUserData(User $user): void
{
    Redis::pipeline(function ($pipe) use ($user) {
        // User Profile
        $pipe->setex(
            "user:{$user->id}:profile",
            3600,
            json_encode($user->toArray())
        );

        // Permissions
        $pipe->setex(
            "user:{$user->id}:permissions",
            3600,
            json_encode($user->getAllPermissions()->pluck('name'))
        );

        // Last Login Update
        $pipe->hset(
            "user:{$user->id}:meta",
            'last_login',
            now()->timestamp
        );

        // Online Status
        $pipe->setex("user:{$user->id}:online", 300, 1);
    });
}

Redis Lua Script — Atomic Operations:

php
// Atomic Stock Deduction — Race Condition ছাড়া
class AtomicStockService
{
    public function deductStock(int $productId, int $quantity): bool
    {
        $script = "
            local stock = tonumber(redis.call('get', KEYS[1]))
            if stock == nil then
                return -1  -- Stock Cache নেই
            end
            if stock < tonumber(ARGV[1]) then
                return 0   -- Stock কম
            end
            redis.call('decrby', KEYS[1], ARGV[1])
            return 1       -- সফল
        ";

        $result = Redis::eval(
            $script,
            1,                              // Key count
            "product:{$productId}:stock",   // KEYS[1]
            $quantity                       // ARGV[1]
        );

        return match($result) {
            1  => true,
            0  => throw new InsufficientStockException(),
            -1 => $this->deductFromDatabase($productId, $quantity),
        };
    }
}

🔵 PART 5 — Memcached

Redis vs Memcached কখন কোনটা?

Redis                          Memcached
─────────────────────          ─────────────────────
Data Structures আছে      vs   শুধু Key-Value
Persistence আছে          vs   Memory Only (Restart = Data হারায়)
Pub/Sub আছে              vs   নেই
Replication আছে          vs   নেই
বেশি Features            vs   Simple ও দ্রুত
Cache + Queue + Session  vs   শুধু Cache

কখন Memcached বেছে নেবেন:
✓ শুধু Simple Caching দরকার
✓ Multi-threaded Performance দরকার
✓ Very Large Cache (কয়েক TB)
✓ Simple Setup চান

php
// Memcached Operations — Laravel এ একই Cache Facade
Cache::store('memcached')->put('key', 'value', 3600);
Cache::store('memcached')->get('key');
Cache::store('memcached')->forget('key');

// Multiple Servers — Consistent Hashing
// config/cache.php
'memcached' => [
    'driver'        => 'memcached',
    'persistent_id' => env('MEMCACHED_PERSISTENT_ID'),
    'sasl'          => [
        env('MEMCACHED_USERNAME'),
        env('MEMCACHED_PASSWORD'),
    ],
    'options' => [
        // Consistent Hashing — Server যোগ/বাদ দিলে কম Cache Miss
        Memcached::OPT_DISTRIBUTION => Memcached::DISTRIBUTION_CONSISTENT,
        Memcached::OPT_LIBKETAMA_COMPATIBLE => true,
    ],
    'servers' => [
        ['host' => '10.0.0.1', 'port' => 11211, 'weight' => 100],
        ['host' => '10.0.0.2', 'port' => 11211, 'weight' => 100],
        ['host' => '10.0.0.3', 'port' => 11211, 'weight' => 100],
    ],
],

🛡️ PART 6 — Cache Problems & Solutions

১. Cache Stampede (Thunder Herd Problem):

সমস্যা: Cache Expire হলো → হাজারো Request একসাথে DB তে গেলো → DB Crash!

                Cache Expire!
                     ↓
[1000 Requests] ──→ [DB] ← অনেক চাপ!

php
// Solution 1 — Mutex/Lock ব্যবহার করুন
class CacheStampedeProtection
{
    public function remember(string $key, int $ttl, callable $callback): mixed
    {
        // Cache আছে? দিন
        if ($value = Cache::get($key)) {
            return $value;
        }

        // Lock নিন — শুধু একজন DB তে যাবে
        $lock = Cache::lock("lock:{$key}", 10);

        try {
            if ($lock->get()) {
                // আমি Lock পেয়েছি — DB থেকে নিই
                $value = $callback();
                Cache::put($key, $value, $ttl);
                return $value;
            }
        } finally {
            $lock->release();
        }

        // Lock পাইনি — একটু অপেক্ষা করে আবার চেক করুন
        sleep(1);
        return Cache::get($key) ?? $callback();
    }
}

// Solution 2 — Probabilistic Early Expiration
class EarlyExpirationCache
{
    public function get(string $key, int $ttl, callable $callback): mixed
    {
        $cached = Cache::get($key);

        if ($cached) {
            // TTL এর ১০% বাকি থাকলে ১% chance এ early refresh
            $remainingTtl = Redis::ttl($key);
            $shouldRefresh = $remainingTtl < ($ttl * 0.1)
                          && random_int(1, 100) === 1;

            if (!$shouldRefresh) {
                return $cached;
            }
        }

        $value = $callback();
        Cache::put($key, $value, $ttl);
        return $value;
    }
}

২. Cache Penetration (DB Attack):

সমস্যা: Hacker বারবার Non-existent Key দিয়ে Request করছে
→ Cache Miss → DB Hit → DB Overwhelmed!

GET /api/products/99999999  ← এই Product নেই!
GET /api/products/88888888  ← এটাও নেই!
... লক্ষবার!

php
// Solution — Null Value Cache করুন
class ProductService
{
    public function getProduct(int $id): ?Product
    {
        $cacheKey = "product:{$id}";

        $cached = Cache::get($cacheKey);

        // Null String মানে আগে চেক করা হয়েছে, নেই
        if ($cached === 'NULL') {
            return null;
        }

        if ($cached !== null) {
            return $cached;
        }

        // DB তে খুঁজুন
        $product = Product::find($id);

        if ($product) {
            Cache::put($cacheKey, $product, now()->addHours(6));
        } else {
            // নেই → Null Cache করুন — ৫ মিনিটের জন্য
            Cache::put($cacheKey, 'NULL', now()->addMinutes(5));
        }

        return $product;
    }
}

// Bloom Filter — আরো ভালো Solution
// সব Valid Product ID Redis এ রাখুন
class BloomFilterService
{
    public function productExists(int $productId): bool
    {
        // Bloom Filter Check — O(1) time
        return Redis::getbit("bloom:products", $productId % 10000000);
    }

    public function addProduct(int $productId): void
    {
        Redis::setbit("bloom:products", $productId % 10000000, 1);
    }
}

// Middleware তে ব্যবহার করুন
public function getProduct(int $id, BloomFilterService $bloom): JsonResponse
{
    // Bloom Filter এ নেই → সরাসরি 404, DB তে যাবে না
    if (!$bloom->productExists($id)) {
        return response()->json(['message' => 'Not found'], 404);
    }

    return response()->json($this->productService->getProduct($id));
}

৩. Cache Avalanche (একসাথে অনেক Cache Expire):

সমস্যা: রাত ১২টায় সব Cache Expire হলো
→ সব Request DB তে গেলো → DB Down!

php
// Solution — TTL তে Random Jitter যোগ করুন
class CacheService
{
// সব Cache একসাথে Expire না হওয়ার জন্য
public function rememberWithJitter(
string $key,
int $baseTtl,
callable $callback,
int $jitterPercent = 20
): mixed {
// Base TTL এর ±20% Random করুন
$jitter = (int) ($baseTtl * $jitterPercent / 100);
$ttl = $baseTtl + random_int(-$jitter, $jitter);

    return Cache::remember($key, $ttl, $callback);
}

}

// ব্যবহার
// ৩৬০০ সেকেন্ড (±২০%) = ২৮৮০ থেকে ৪৩২০ সেকেন্ডের মধ্যে যেকোনো সময় expire
$product = $cacheService->rememberWithJitter(
"product:{$id}",
3600,
fn() => Product::find($id)
);


---

📊 **PART 7 — Full Cache Layer — Real Project**

php
// app/Services/CacheLayerService.php
// সব ধরনের Cache একটা Service এ

class CacheLayerService
{
// L1: Array Cache (Request scope — সবচেয়ে দ্রুত)
private array $requestCache = [];

// L2: Redis (Application scope)
// L3: Database (সবচেয়ে ধীর)

public function getProduct(int $id): ?Product
{
    // L1 — Same Request এ আগে দেখা? Array থেকে নিন
    if (isset($this->requestCache["product:{$id}"])) {
        return $this->requestCache["product:{$id}"];
    }

    // L2 — Redis Cache তে আছে?
    $product = Cache::remember(
        CacheKey::product($id),
        now()->addHours(6),
        function () use ($id) {
            // L3 — Database থেকে নিন
            return Product::with(['category', 'brand', 'images'])
                          ->find($id);
        }
    );

    // L1 এ রাখুন — এই Request এ আবার লাগলে দ্রুত পাবো
    $this->requestCache["product:{$id}"] = $product;

    return $product;
}

// Dashboard Cache — Multiple Data একসাথে
public function getDashboardData(int $userId): array
{
    return Cache::remember(
        "dashboard:user:{$userId}",
        now()->addMinutes(15),
        function () use ($userId) {
            // সব Data একসাথে Load করুন
            return [
                'total_orders'    => Order::where('user_id', $userId)->count(),
                'pending_orders'  => Order::where('user_id', $userId)
                                          ->where('status', 'pending')->count(),
                'total_spent'     => Order::where('user_id', $userId)
                                          ->where('status', 'completed')
                                          ->sum('total'),
                'wishlist_count'  => Wishlist::where('user_id', $userId)->count(),
                'recent_orders'   => Order::where('user_id', $userId)
                                          ->with('items.product')
                                          ->latest()
                                          ->take(5)
                                          ->get(),
                'recommended'     => $this->getRecommendations($userId),
            ];
        }
    );
}

// Cache Warming — Deploy এর পরে Cache গরম করুন
public function warmCache(): void
{
    // Popular Products Cache করুন
    $popularProducts = Product::withCount('orders')
                              ->orderByDesc('orders_count')
                              ->take(100)
                              ->get();

    foreach ($popularProducts as $product) {
        Cache::put(
            CacheKey::product($product->id),
            $product->load(['category', 'brand']),
            now()->addHours(6)
        );
    }

    // Categories Cache করুন
    Cache::put(
        'all_categories',
        Category::where('is_active', true)->get(),
        now()->addDay()
    );

    Log::info('Cache warmed successfully', [
        'products_cached' => $popularProducts->count()
    ]);
}

}

// Artisan Command — Deploy এর পরে Cache Warm করুন
class WarmCacheCommand extends Command
{
protected $signature = 'cache:warm';
protected $description = 'Warm application cache after deployment';

public function handle(CacheLayerService $cacheService): void
{
    $this->info('Cache warming শুরু হচ্ছে...');

    $start = microtime(true);
    $cacheService->warmCache();
    $time  = round(microtime(true) - $start, 2);

    $this->info("✅ Cache warming সম্পন্ন! সময় লেগেছে: {$time}s");
}

}
// চালান: php artisan cache:warm


---

📈 **PART 8 — Cache Monitoring**

php
// Cache Hit Rate Monitor করুন
class CacheMonitorMiddleware
{
public function handle(Request $request, Closure $next): Response
{
// Cache Event Listen করুন
Event::listen(CacheHit::class, function ($event) {
Redis::incr('metrics:cache:hits');
});

    Event::listen(CacheMissed::class, function ($event) {
        Redis::incr('metrics:cache:misses');
    });

    return $next($request);
}

}

// Cache Stats দেখুন
class CacheStatsController extends Controller
{
public function stats(): JsonResponse
{
$hits = (int) Redis::get('metrics:cache:hits') ?? 0;
$misses = (int) Redis::get('metrics:cache:misses') ?? 0;
$total = $hits + $misses;

    $info   = Redis::info('memory');

    return response()->json([
        'hit_rate'    => $total > 0
                          ? round($hits / $total * 100, 2) . '%'
                          : '0%',
        'total_hits'  => $hits,
        'total_misses'=> $misses,
        'memory_used' => $info['used_memory_human'],
        'memory_peak' => $info['used_memory_peak_human'],
    ]);
}

}


---

📝 **সংক্ষেপে মনে রাখুন**
**Cache কেন** — Database চাপ কমাতে এবং Response দ্রুত করতে। 
**Redis** — Cache ছাড়াও Queue, Session, Pub/Sub, Leaderboard সব করা যায় — Laravel এ সবচেয়ে জনপ্রিয়। 
**Memcached** — শুধু Simple Caching দরকার হলে এবং Multi-threaded Performance দরকার হলে। 
**Cache Strategies** — Cache-Aside সবচেয়ে জনপ্রিয়, Write-Through Critical Data এর জন্য, Write-Behind Analytics এর জন্য। 
**সমস্যাগুলো** — Stampede (Lock দিয়ে), Penetration (Null Cache দিয়ে), Avalanche (Jitter দিয়ে) সমাধান করুন।
Real Project এ **Redis** ব্যবহার করুন — এটাই যথেষ্ট। Cache Key Design ভালো রাখুন এবং Cache Invalidation সতর্কভাবে করুন।

**_Q:6_** - Security (OAuth2, JWT, encryption)
**Answer:**

🔐 **Security কেন গুরুত্বপূর্ণ?**

একটা Security Breach এর পরিণাম:
├── User এর Personal Data চুরি
├── Financial Loss
├── Company এর Reputation নষ্ট
├── Legal Penalty (GDPR Fine)
└── Service Down

বাস্তব উদাহরণ:
2013 → Adobe: 38 মিলিয়ন User Data চুরি
2016 → Uber: 57 মিলিয়ন User Data চুরি
2021 → Facebook: 533 মিলিয়ন User Data Leak


---

🔵 **PART 1 — Authentication vs Authorization**

Authentication (প্রমাণ) Authorization (অনুমতি)
──────────────────────── ────────────────────────
"তুমি কে?" vs "তুমি কী করতে পারবে?"

উদাহরণ:
আপনি Bank এ গেলেন → Authentication (NID দেখালেন)
Locker Room এ গেলেন → Authorization (আপনার Locker নম্বর আছে)


---

🟡 **PART 2 — JWT (JSON Web Token)**
**JWT কী?**
JWT হলো একটা **Self-contained Token** — যেখানে User এর তথ্য **Encoded** থাকে। Server কে Database এ যেতে হয় না Token Verify করতে।

JWT Structure — তিনটা Part, Dot দিয়ে আলাদা:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9 ← Header (Base64)
.eyJ1c2VyX2lkIjoxLCJlbWFpbCI6InRlc3Q ← Payload (Base64)
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV ← Signature (HMAC)

Header: {"alg": "HS256", "typ": "JWT"}
Payload: {"user_id": 1, "email": "test@example.com", "exp": 1700000000}
Signature: HMACSHA256(header + payload, SECRET_KEY)

**Laravel-এ JWT Implementation:**

bash
composer require php-open-source-saver/jwt-auth
php artisan vendor:publish --provider="PHPOpenSourceSaver\JWTAuth\Providers\LaravelServiceProvider"
php artisan jwt:secret

php
// .env
JWT_SECRET=your-super-secret-key-minimum-32-characters
JWT_TTL=60 // Access Token — ৬০ মিনিট
JWT_REFRESH_TTL=20160 // Refresh Token — ১৪ দিন

// config/auth.php
'guards' => [
'api' => [
'driver' => 'jwt',
'provider' => 'users',
],
],

**JWT Auth Controller — Complete Implementation:**

php
// app/Http/Controllers/Api/AuthController.php
class AuthController extends Controller
{
// ১. Register
public function register(RegisterRequest $request): JsonResponse
{
$user = User::create([
'name' => $request->name,
'email' => $request->email,
'password' => bcrypt($request->password),
]);

    // Token Generate করুন
    $token = auth('api')->login($user);

    return $this->respondWithToken($token, $user, 201);
}

// ২. Login
public function login(LoginRequest $request): JsonResponse
{
    $credentials = $request->only('email', 'password');

    // Brute Force Protection
    if ($this->hasTooManyLoginAttempts($request)) {
        return response()->json([
            'message' => 'অনেকবার চেষ্টা করেছেন। ১৫ মিনিট পরে try করুন।',
            'retry_after' => $this->limiter->availableIn(
                $this->throttleKey($request)
            ),
        ], 429);
    }

    if (!$token = auth('api')->attempt($credentials)) {
        // Failed Attempt Count বাড়ান
        $this->incrementLoginAttempts($request);

        return response()->json([
            'message' => 'Email বা Password ভুল।',
        ], 401);
    }

    // Success — Attempt Reset করুন
    $this->clearLoginAttempts($request);

    // Login Log রাখুন
    $this->logLoginActivity($request);

    return $this->respondWithToken($token);
}

// ৩. Logout
public function logout(): JsonResponse
{
    // Token Blacklist এ রাখুন
    auth('api')->logout();

    return response()->json([
        'message' => 'সফলভাবে Logout হয়েছেন।'
    ]);
}

// ৪. Token Refresh
public function refresh(): JsonResponse
{
    try {
        $newToken = auth('api')->refresh();
        return $this->respondWithToken($newToken);

    } catch (TokenExpiredException $e) {
        return response()->json([
            'message' => 'Refresh Token Expired। আবার Login করুন।'
        ], 401);
    }
}

// ৫. Current User
public function me(): JsonResponse
{
    $user = auth('api')->user();

    return response()->json([
        'user' => new UserResource($user),
    ]);
}

// Token Response Format
private function respondWithToken(
    string $token,
    ?User $user = null,
    int $status = 200
): JsonResponse {
    $user ??= auth('api')->user();

    return response()->json([
        'access_token' => $token,
        'token_type'   => 'Bearer',
        'expires_in'   => auth('api')->factory()->getTTL() * 60,
        'user'         => new UserResource($user),
    ], $status);
}

// Login Activity Log
private function logLoginActivity(Request $request): void
{
    LoginActivity::create([
        'user_id'    => auth('api')->id(),
        'ip_address' => $request->ip(),
        'user_agent' => $request->userAgent(),
        'location'   => $this->getLocationFromIp($request->ip()),
        'logged_at'  => now(),
    ]);
}

}

**JWT Middleware — Token Verify করুন:**

php
// app/Http/Middleware/JwtMiddleware.php
class JwtMiddleware
{
public function handle(Request $request, Closure $next): Response
{
try {
// Token থেকে User নিন
$user = JWTAuth::parseToken()->authenticate();

        if (!$user) {
            return response()->json([
                'message' => 'User not found'
            ], 401);
        }

        // User Active আছে?
        if (!$user->is_active) {
            return response()->json([
                'message' => 'আপনার Account Suspended।'
            ], 403);
        }

    } catch (TokenExpiredException $e) {
        return response()->json([
            'message' => 'Token Expired। Refresh করুন।',
            'error'   => 'token_expired',
        ], 401);

    } catch (TokenInvalidException $e) {
        return response()->json([
            'message' => 'Token Invalid।',
            'error'   => 'token_invalid',
        ], 401);

    } catch (JWTException $e) {
        return response()->json([
            'message' => 'Token দেওয়া হয়নি।',
            'error'   => 'token_absent',
        ], 401);
    }

    return $next($request);
}

}

**Access Token + Refresh Token Pattern:**

php
// app/Services/TokenService.php
class TokenService
{
// Short-lived Access Token + Long-lived Refresh Token
public function generateTokenPair(User $user): array
{
// Access Token — ১৫ মিনিট
$accessToken = JWTAuth::customClaims([
'type' => 'access',
'user_id' => $user->id,
])->fromUser($user);

    // Refresh Token — ৩০ দিন (DB তে Store করুন)
    $refreshToken = Str::random(64);

    // DB তে Refresh Token Store করুন
    RefreshToken::create([
        'user_id'    => $user->id,
        'token'      => hash('sha256', $refreshToken), // Hash করে রাখুন
        'expires_at' => now()->addDays(30),
        'ip_address' => request()->ip(),
    ]);

    return [
        'access_token'  => $accessToken,
        'refresh_token' => $refreshToken,
        'expires_in'    => 900, // ১৫ মিনিট
    ];
}

// Refresh Token দিয়ে নতুন Access Token নিন
public function refreshAccessToken(string $refreshToken): array
{
    $hashedToken = hash('sha256', $refreshToken);

    $storedToken = RefreshToken::where('token', $hashedToken)
                               ->where('expires_at', '>', now())
                               ->whereNull('revoked_at')
                               ->with('user')
                               ->firstOrFail();

    // পুরনো Refresh Token Revoke করুন (Rotation)
    $storedToken->update(['revoked_at' => now()]);

    // নতুন Token Pair Generate করুন
    return $this->generateTokenPair($storedToken->user);
}

// Logout — সব Token Revoke করুন
public function revokeAllTokens(int $userId): void
{
    RefreshToken::where('user_id', $userId)
                ->whereNull('revoked_at')
                ->update(['revoked_at' => now()]);

    JWTAuth::invalidate(JWTAuth::getToken());
}

}


---

🟠 **PART 3 — OAuth2**

**OAuth2 কী?**

OAuth2 হলো **Third-party Authorization** এর Standard। "Google দিয়ে Login" বা "Facebook দিয়ে Login" — এটাই OAuth2।

OAuth2 Flow:

[User] → "Google দিয়ে Login" → [Your App]
↓
[Google Auth Server]
↓ (User Allow করলো)
Authorization Code
↓
[Your App এ Code পাঠালো]
↓
Code দিয়ে Access Token নিন
↓
Access Token দিয়ে User Info নিন
↓
[User Logged In!]

**Laravel Passport — Full OAuth2 Server:**

bash
composer require laravel/passport
php artisan passport:install
php artisan passport:keys

php
// app/Models/User.php
class User extends Authenticatable
{
use HasApiTokens; // Passport এর জন্য
}

// app/Providers/AppServiceProvider.php
public function boot(): void
{
// Token Expiry Configure করুন
Passport::tokensExpireIn(now()->addMinutes(15));
Passport::refreshTokensExpireIn(now()->addDays(30));
Passport::personalAccessTokensExpireIn(now()->addMonths(6));

// Scopes Define করুন — Permission Level
Passport::tokensCan([
    'read-products'   => 'Products দেখার অনুমতি',
    'write-products'  => 'Products তৈরি/edit করার অনুমতি',
    'read-orders'     => 'Orders দেখার অনুমতি',
    'write-orders'    => 'Orders তৈরি করার অনুমতি',
    'admin'           => 'সব কিছু করার অনুমতি',
]);

}

**OAuth2 Client Credentials (Machine to Machine):**

php
php
// routes/api.php
Route::middleware('client')->group(function () {
// শুধু Authenticated Client Access করতে পারবে
Route::get('/internal/products', [InternalProductController::class, 'index']);
Route::post('/internal/sync', [SyncController::class, 'sync']);
});

// Client Credentials Grant — Service to Service Auth
class InternalSyncService
{
private ?string $accessToken = null;

public function getToken(): string
{
    // Cache করুন — বারবার নেওয়া লাগবে না
    if ($this->accessToken && !$this->isTokenExpired()) {
        return $this->accessToken;
    }

    $response = Http::post(config('services.auth.url') . '/oauth/token', [
        'grant_type'    => 'client_credentials',
        'client_id'     => config('services.auth.client_id'),
        'client_secret' => config('services.auth.client_secret'),
        'scope'         => 'read-products write-products',
    ]);

    $this->accessToken = $response->json('access_token');

    Cache::put(
        'service_access_token',
        $this->accessToken,
        now()->addMinutes(14) // Expire এর ১ মিনিট আগে
    );

    return $this->accessToken;
}

public function syncProducts(): void
{
    $token = $this->getToken();

    Http::withToken($token)
        ->post(config('services.inventory.url') . '/internal/sync', [
            'products' => Product::all()->toArray()
        ]);
}

}

**Social Login — Google/Facebook দিয়ে Login:**

php
bash
composer require laravel/socialite

shell
php
// config/services.php
'google' => [
'client_id' => env('GOOGLE_CLIENT_ID'),
'client_secret' => env('GOOGLE_CLIENT_SECRET'),
'redirect' => env('GOOGLE_REDIRECT_URI'),
],

'facebook' => [
'client_id' => env('FACEBOOK_APP_ID'),
'client_secret' => env('FACEBOOK_APP_SECRET'),
'redirect' => env('FACEBOOK_REDIRECT_URI'),
],

// app/Http/Controllers/Auth/SocialAuthController.php
class SocialAuthController extends Controller
{
// ১. Google/Facebook এ Redirect করুন
public function redirect(string $provider): RedirectResponse
{
$validProviders = ['google', 'facebook', 'github'];

    if (!in_array($provider, $validProviders)) {
        return response()->json(['message' => 'Invalid provider'], 400);
    }

    return Socialite::driver($provider)->redirect();
}

// ২. Callback — Google/Facebook থেকে ফিরে আসলে
public function callback(string $provider): JsonResponse
{
    try {
        $socialUser = Socialite::driver($provider)->user();

    } catch (\Exception $e) {
        return response()->json([
            'message' => 'Social Login ব্যর্থ হয়েছে।'
        ], 401);
    }

    // Email দিয়ে User খুঁজুন
    $user = User::where('email', $socialUser->getEmail())->first();

    if ($user) {
        // আগে Register করেছে → Social Account Link করুন
        $user->socialAccounts()->updateOrCreate(
            ['provider' => $provider],
            [
                'provider_id'    => $socialUser->getId(),
                'provider_token' => $socialUser->token,
                'avatar'         => $socialUser->getAvatar(),
            ]
        );

    } else {
        // নতুন User → Register করুন
        $user = DB::transaction(function () use ($socialUser, $provider) {
            $newUser = User::create([
                'name'              => $socialUser->getName(),
                'email'             => $socialUser->getEmail(),
                'email_verified_at' => now(), // Social Login = Email Verified
                'password'          => bcrypt(Str::random(32)), // Random Password
                'avatar'            => $socialUser->getAvatar(),
            ]);

            $newUser->socialAccounts()->create([
                'provider'       => $provider,
                'provider_id'    => $socialUser->getId(),
                'provider_token' => $socialUser->token,
            ]);

            return $newUser;
        });
    }

    // JWT Token Generate করুন
    $token = auth('api')->login($user);

    return response()->json([
        'access_token' => $token,
        'token_type'   => 'Bearer',
        'user'         => new UserResource($user),
    ]);
}

}


---

🟢 **PART 4 — Encryption (এনক্রিপশন)**

**Encryption এর ধরন:**

php
Symmetric Encryption → একই Key দিয়ে Encrypt ও Decrypt
AES-256 — দ্রুত, Bulk Data এর জন্য

Asymmetric Encryption → Public Key দিয়ে Encrypt
Private Key দিয়ে Decrypt
RSA — ধীর, Key Exchange এর জন্য

Hashing → One-way, Decrypt করা যায় না
bcrypt, argon2 — Password Storage এর জন্য

**Laravel-এ Encryption:**

plaintext
php
// ১. Built-in Encryption — Sensitive Data
class SensitiveDataService
{
// Encrypt করুন — DB তে Store করার আগে
public function storeSensitiveData(array $data): UserProfile
{
return UserProfile::create([
'user_id' => auth()->id(),
// Encrypt করে রাখুন
'national_id' => encrypt($data['national_id']),
'bank_account' => encrypt($data['bank_account']),
'phone' => encrypt($data['phone']),
// Normal Data
'name' => $data['name'],
]);
}

// Decrypt করুন — ব্যবহারের সময়
public function getSensitiveData(int $userId): array
{
    $profile = UserProfile::where('user_id', $userId)->firstOrFail();

    return [
        'name'         => $profile->name,
        'national_id'  => decrypt($profile->national_id),
        'bank_account' => decrypt($profile->bank_account),
        'phone'        => decrypt($profile->phone),
    ];
}

}

// ২. Model Casting — Automatic Encrypt/Decrypt
class UserProfile extends Model
{
protected $casts = [
// Laravel 9+ — Automatic Encrypt/Decrypt
'national_id' => 'encrypted',
'bank_account' => 'encrypted',
'metadata' => 'encrypted:array', // Array ও Encrypt করা যায়
];
}

// ব্যবহার — Automatic!
$profile = UserProfile::create([
'national_id' => '1234567890', // Automatically Encrypted
]);

echo $profile->national_id; // Automatically Decrypted → 1234567890

// ৩. Custom Encryption — AES-256
class EncryptionService
{
private string $key;
private string $cipher = 'AES-256-CBC';

public function __construct()
{
    $this->key = base64_decode(config('app.encryption_key'));
}

public function encrypt(string $data): string
{
    $iv        = random_bytes(openssl_cipher_iv_length($this->cipher));
    $encrypted = openssl_encrypt($data, $this->cipher, $this->key, 0, $iv);
    $hmac      = hash_hmac('sha256', $encrypted, $this->key, true);

    // IV + HMAC + Encrypted Data একসাথে রাখুন
    return base64_encode($iv . $hmac . $encrypted);
}

public function decrypt(string $encryptedData): string
{
    $decoded   = base64_decode($encryptedData);
    $ivLength  = openssl_cipher_iv_length($this->cipher);
    $iv        = substr($decoded, 0, $ivLength);
    $hmac      = substr($decoded, $ivLength, 32);
    $encrypted = substr($decoded, $ivLength + 32);

    // HMAC Verify করুন — Tamper Check
    $expectedHmac = hash_hmac('sha256', $encrypted, $this->key, true);

    if (!hash_equals($expectedHmac, $hmac)) {
        throw new DecryptException('Data tampered! HMAC mismatch.');
    }

    return openssl_decrypt($encrypted, $this->cipher, $this->key, 0, $iv);
}

}

**Password Hashing — সঠিকভাবে:**

php
php
// ১. Password Store করুন — bcrypt (Default)
$user = User::create([
'password' => Hash::make($request->password), // bcrypt
]);

// অথবা Argon2 (আরো শক্তিশালী)
$hash = Hash::driver('argon2id')->make($request->password);

// ২. Password Verify করুন
if (!Hash::check($request->password, $user->password)) {
throw new UnauthorizedException('Password ভুল।');
}

// ৩. Password Rehash — Algorithm Update হলে
if (Hash::needsRehash($user->password)) {
$user->update([
'password' => Hash::make($request->password)
]);
}

// ❌ কখনো এভাবে করবেন না
$user->password = md5($password); // MD5 — ভাঙা!
$user->password = sha1($password); // SHA1 — ভাঙা!
$user->password = $password; // Plain text — মারাত্মক!


---

🛡️ **PART 5 — Authorization (Role & Permission)**
**Spatie Permission — Professional RBAC:**

php
bash
composer require spatie/laravel-permission
php artisan vendor:publish --provider="Spatie\Permission\PermissionServiceProvider"
php artisan migrate

shell
php
// Roles ও Permissions তৈরি করুন
class RolePermissionSeeder extends Seeder
{
public function run(): void
{
// Permissions তৈরি করুন
$permissions = [
// Products
'products.view', 'products.create',
'products.edit', 'products.delete',
// Orders
'orders.view', 'orders.manage',
'orders.refund',
// Users
'users.view', 'users.create',
'users.edit', 'users.delete', 'users.ban',
// Settings
'settings.view', 'settings.manage',
];

    foreach ($permissions as $permission) {
        Permission::create(['name' => $permission]);
    }

    // Roles তৈরি করুন এবং Permissions দিন
    $superAdmin = Role::create(['name' => 'super-admin']);
    $superAdmin->givePermissionTo(Permission::all()); // সব Permission

    $admin = Role::create(['name' => 'admin']);
    $admin->givePermissionTo([
        'products.view', 'products.create', 'products.edit',
        'orders.view', 'orders.manage',
        'users.view',
    ]);

    $seller = Role::create(['name' => 'seller']);
    $seller->givePermissionTo([
        'products.view', 'products.create', 'products.edit',
        'orders.view',
    ]);

    $customer = Role::create(['name' => 'customer']);
    $customer->givePermissionTo([
        'products.view',
        'orders.view',
    ]);
}

}

// Policy — Object Level Permission
class ProductPolicy
{
// Product দেখার অনুমতি
public function view(User $user, Product $product): bool
{
return $user->hasPermissionTo('products.view');
}

// Product Edit — নিজের বা Admin
public function update(User $user, Product $product): bool
{
    return $user->id === $product->user_id
        || $user->hasRole(['admin', 'super-admin']);
}

// Product Delete — শুধু Admin
public function delete(User $user, Product $product): bool
{
    return $user->hasRole(['admin', 'super-admin'])
        || ($user->id === $product->user_id
            && $user->hasPermissionTo('products.delete'));
}

}

// Controller এ ব্যবহার করুন
class ProductController extends Controller
{
public function update(UpdateProductRequest $request, Product $product)
{
// Policy Check — Permission নেই? Automatically 403
$this->authorize('update', $product);

    $product->update($request->validated());

    return new ProductResource($product);
}

public function destroy(Product $product)
{
    $this->authorize('delete', $product);

    $product->delete();

    return response()->json(['message' => 'Product deleted']);
}

}

// Blade এ Permission Check
@can('products.create')
নতুন Product যোগ করুন
@endcan

@role('admin|super-admin')
Admin Panel
@endrole


---

🔒 **PART 6 — Common Security Vulnerabilities**
**SQL Injection থেকে রক্ষা:**

php
php
// ❌ ভুল — SQL Injection এর সুযোগ!
$products = DB::select(
"SELECT * FROM products WHERE name = '$request->name'"
);

// ✅ সঠিক — Parameterized Query
$products = DB::select(
'SELECT * FROM products WHERE name = ?',
[$request->name]
);

// ✅ আরো ভালো — Eloquent ORM
$products = Product::where('name', $request->name)->get();

**XSS (Cross-Site Scripting) থেকে রক্ষা:**

php
php
// ❌ ভুল — XSS এর সুযোগ!
return response("

Hello {$request->name}

");

// ✅ সঠিক — Escape করুন
return response("

Hello " . e($request->name) . "

");

// ✅ Blade Template — Automatically Escape
{{ $user->name }} // Safe — Escaped
{!! $user->bio !!} // Unsafe — Raw HTML

// Input Sanitize করুন
class SanitizeInput
{
public static function clean(string $input): string
{
// HTML Tags সরিয়ে দিন
$input = strip_tags($input);

    // Special Characters Encode করুন
    $input = htmlspecialchars($input, ENT_QUOTES, 'UTF-8');

    // Extra Whitespace সরান
    return trim($input);
}

}

// Content Security Policy Header
class SecurityHeadersMiddleware
{
public function handle(Request $request, Closure $next): Response
{
$response = $next($request);

    $response->headers->set(
        'Content-Security-Policy',
        "default-src 'self'; " .
        "script-src 'self' 'nonce-" . csrf_token() . "'; " .
        "style-src 'self' https://fonts.googleapis.com; " .
        "img-src 'self' data: https:; " .
        "font-src 'self' https://fonts.gstatic.com;"
    );

    $response->headers->set('X-Content-Type-Options', 'nosniff');
    $response->headers->set('X-Frame-Options', 'DENY');
    $response->headers->set('X-XSS-Protection', '1; mode=block');
    $response->headers->set(
        'Strict-Transport-Security',
        'max-age=31536000; includeSubDomains'
    );

    return $response;
}

}

**CSRF Protection:**

php
php
// Laravel Automatically CSRF Protect করে Web Routes এ
// API Routes এ Stateless Token ব্যবহার করুন

// Exempt করুন — Webhook Routes
// app/Http/Middleware/VerifyCsrfToken.php
protected $except = [
'webhook/*',
'api/payment/callback',
];

// API এ Sanctum Token ব্যবহার করুন
Route::middleware('auth:sanctum')->group(function () {
Route::post('/products', [ProductController::class, 'store']);
});

**Rate Limiting — Advanced:**

php
php
// app/Providers/AppServiceProvider.php
public function boot(): void
{
// API Rate Limit
RateLimiter::for('api', function (Request $request) {
return $request->user()
? Limit::perMinute(120)->by($request->user()->id)
: Limit::perMinute(30)->by($request->ip());
});

// Login Rate Limit — Brute Force Protection
RateLimiter::for('login', function (Request $request) {
    return [
        Limit::perMinute(5)->by($request->input('email')),
        Limit::perMinute(10)->by($request->ip()),
    ];
});

// OTP Rate Limit
RateLimiter::for('otp', function (Request $request) {
    return Limit::perHour(3)->by($request->input('phone'));
});

// Expensive Operations
RateLimiter::for('reports', function (Request $request) {
    return Limit::perHour(5)
                ->by($request->user()->id)
                ->response(function () {
                    return response()->json([
                        'message' => 'প্রতি ঘন্টায় সর্বোচ্চ ৫টা Report Generate করা যাবে।'
                    ], 429);
                });
});

}


---


🔏 **PART 7 — API Security Best Practices**

php
php
// app/Http/Middleware/ApiSecurityMiddleware.php
class ApiSecurityMiddleware
{
public function handle(Request $request, Closure $next): Response
{
// ১. HTTPS Check
if (!$request->secure() && config('app.env') === 'production') {
return response()->json([
'message' => 'HTTPS Required'
], 403);
}

    // ২. API Version Check
    $version = $request->header('X-API-Version', '1');
    if (!in_array($version, ['1', '2'])) {
        return response()->json([
            'message' => 'Unsupported API Version'
        ], 400);
    }

    // ৩. Request Size Limit — Large Payload Attack থেকে রক্ষা
    $contentLength = $request->header('Content-Length', 0);
    if ($contentLength > 10 * 1024 * 1024) { // ১০ MB
        return response()->json([
            'message' => 'Request Too Large'
        ], 413);
    }

    // ৪. Suspicious Pattern Detect করুন
    $body = $request->getContent();
    if ($this->hasSqlInjection($body) || $this->hasXssPattern($body)) {
        Log::warning('Suspicious request detected', [
            'ip'  => $request->ip(),
            'url' => $request->fullUrl(),
        ]);

        return response()->json([
            'message' => 'Invalid Request'
        ], 400);
    }

    $response = $next($request);

    // ৫. Sensitive Data Response Header সরিয়ে দিন
    $response->headers->remove('X-Powered-By');
    $response->headers->remove('Server');
    $response->headers->set('X-Request-ID', Str::uuid());

    return $response;
}

private function hasSqlInjection(string $input): bool
{
    $patterns = [
        '/(\bunion\b.*\bselect\b)/i',
        '/(\bselect\b.*\bfrom\b)/i',
        '/(\bdrop\b.*\btable\b)/i',
        '/(\bdelete\b.*\bfrom\b)/i',
        "/(--|\#|\/\*)/",
    ];

    foreach ($patterns as $pattern) {
        if (preg_match($pattern, $input)) {
            return true;
        }
    }

    return false;
}

private function hasXssPattern(string $input): bool
{
    $patterns = [
        '/<script\b[^>]*>/i',
        '/javascript:/i',
        '/on\w+\s*=/i',
    ];

    foreach ($patterns as $pattern) {
        if (preg_match($pattern, $input)) {
            return true;
        }
    }

    return false;
}

}

// Sensitive Data Masking — Log এ Sensitive Data রাখবেন না
class MaskSensitiveData
{
private array $sensitiveFields = [
'password', 'password_confirmation',
'credit_card', 'card_number', 'cvv',
'national_id', 'bank_account',
'token', 'secret', 'api_key',
];

public function mask(array $data): array
{
    foreach ($data as $key => $value) {
        if (in_array(strtolower($key), $this->sensitiveFields)) {
            $data[$key] = '***MASKED***';
        } elseif (is_array($value)) {
            $data[$key] = $this->mask($value);
        }
    }

    return $data;
}

}


---


🏗️ **PART 8 — Two Factor Authentication (2FA)**

php
php
// app/Services/TwoFactorService.php
class TwoFactorService
{
// ১. 2FA Enable করুন
public function enable(User $user): array
{
// Secret Key Generate করুন
$secret = Google2FA::generateSecretKey();

    // Backup Codes Generate করুন
    $backupCodes = collect(range(1, 8))
                        ->map(fn() => Str::random(10))
                        ->toArray();

    // DB তে রাখুন (Encrypted)
    $user->update([
        'two_factor_secret'  => encrypt($secret),
        'two_factor_backup'  => encrypt(json_encode(
            array_map('bcrypt', $backupCodes)
        )),
        'two_factor_enabled' => false, // Confirm না হওয়া পর্যন্ত
    ]);

    // QR Code URL Generate করুন
    $qrCodeUrl = Google2FA::getQRCodeUrl(
        config('app.name'),
        $user->email,
        $secret
    );

    return [
        'secret'       => $secret,
        'qr_code_url'  => $qrCodeUrl,
        'backup_codes' => $backupCodes,
    ];
}

// ২. OTP Verify করুন
public function verify(User $user, string $otp): bool
{
    $secret = decrypt($user->two_factor_secret);

    // Google Authenticator OTP Check
    $valid = Google2FA::verifyKey($secret, $otp, 1); // 1 = 30 sec window

    if (!$valid) {
        // Backup Code Check
        $valid = $this->verifyBackupCode($user, $otp);
    }

    if ($valid && !$user->two_factor_enabled) {
        $user->update(['two_factor_enabled' => true]);
    }

    return $valid;
}

// ৩. Login এ 2FA Check
public function challengeCheck(Request $request): JsonResponse
{
    $user = auth('api')->user();

    if (!$user->two_factor_enabled) {
        return response()->json(['requires_2fa' => false]);
    }

    // 2FA Token পাঠান Session এ রাখুন
    $challengeToken = Str::random(32);
    Cache::put(
        "2fa_challenge:{$challengeToken}",
        $user->id,
        now()->addMinutes(5)
    );

    // Current Token Invalidate করুন
    auth('api')->logout();

    return response()->json([
        'requires_2fa'    => true,
        'challenge_token' => $challengeToken,
        'message'         => 'Google Authenticator থেকে OTP দিন।',
    ]);
}

}


---


📝 **সংক্ষেপে মনে রাখুন**
**JWT** — Stateless Authentication, Self-contained Token, Microservices এর জন্য আদর্শ। Access Token ছোট (১৫ মিনিট), Refresh Token বড় (৩০ দিন) রাখুন।
**OAuth2** — Third-party Login (Google, Facebook) এবং Machine-to-Machine Auth এর জন্য। Laravel Passport দিয়ে সহজে করা যায়।
**Encryption** — Sensitive Data (NID, Bank Account) সবসময় Encrypt করে রাখুন। Password সবসময় bcrypt/argon2 দিয়ে Hash করুন, কখনো Plain text না।
**Security Best Practices** — SQL Injection (Eloquent ORM), XSS (Escape), CSRF (Token), Rate Limiting, HTTPS — এই সবগুলো একসাথে মেনে চলুন।

**_Q:7_** - **DevOps (CI/CD, Docker, Kubernetes)**
**Answer**: 

🚀 **DevOps কী?**

php
আগে (Traditional):
Developer → Code লিখলো → IT Team কে দিলো → ২ সপ্তাহ পরে Deploy!
↑ ধীর, Error প্রবণ

DevOps (এখন):
Developer → Code Push → Auto Test → Auto Build → Auto Deploy
↑ মিনিটের মধ্যে!

DevOps = Development + Operations
লক্ষ্য: দ্রুত, নিরাপদ, বারবার Software Deliver করা


---

🐳 **PART 1 — Docker**
**Docker কী?**
Docker হলো **Container** Technology। আপনার অ্যাপ এবং তার সব Dependencies একটা **Box (Container)** এ রেখে দেওয়া — যেকোনো Server এ একই ভাবে চলবে।

php
সমস্যা (Docker ছাড়া):
"আমার Machine এ কাজ করে কিন্তু
Server এ করে না!" ← সবচেয়ে বিখ্যাত সমস্যা 😅

সমাধান (Docker সহ):
Container এ সব আছে:
├── PHP 8.3
├── Laravel App
├── Composer Dependencies
├── Nginx Config
└── Environment Variables
→ যেকোনো জায়গায় একই রেজাল্ট!

VM vs Container:
┌─────────────────────┐ ┌─────────────────────┐
│ Virtual Machine │ │ Docker Container │
├─────────────────────┤ ├─────────────────────┤
│ Full OS (2-4 GB) │ │ App + Libs (50 MB) │
│ Slow Start (মিনিট) │ │ Fast Start (সেকেন্ড)│
│ Heavy │ │ Lightweight │
└─────────────────────┘ └─────────────────────┘

**Laravel Project এর জন্য Dockerfile:**

plaintext
dockerfile# Dockerfile

─────────────────────────────────────────

Stage 1: Dependencies Install

─────────────────────────────────────────

FROM php:8.3-fpm-alpine AS dependencies

System Dependencies Install করুন

RUN apk add --no-cache \
git \
curl \
libpng-dev \
libxml2-dev \
zip \
unzip \
nodejs \
npm

PHP Extensions Install করুন

RUN docker-php-ext-install \
pdo \
pdo_mysql \
mbstring \
exif \
pcntl \
bcmath \
gd \
opcache

Redis Extension

RUN pecl install redis && docker-php-ext-enable redis

Composer Install করুন

COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

Working Directory Set করুন

WORKDIR /var/www/html

Dependencies Install করুন (Code আগে না)

এতে Docker Cache কাজ করে — দ্রুত Build

COPY composer.json composer.lock ./
RUN composer install \
--no-dev \
--no-interaction \
--prefer-dist \
--optimize-autoloader

NPM Dependencies

COPY package.json package-lock.json ./
RUN npm ci

─────────────────────────────────────────

Stage 2: Production Image

─────────────────────────────────────────

FROM php:8.3-fpm-alpine AS production

WORKDIR /var/www/html

Dependencies Stage থেকে নিন

COPY --from=dependencies /var/www/html/vendor ./vendor
COPY --from=dependencies /usr/local/lib/php /usr/local/lib/php

Application Code Copy করুন

COPY . .

Assets Build করুন

RUN npm run build && rm -rf node_modules

Laravel Optimization

RUN php artisan config:cache && \
php artisan route:cache && \
php artisan view:cache && \
php artisan event:cache

Permissions Set করুন

RUN chown -R www-data:www-data /var/www/html/storage \
/var/www/html/bootstrap/cache

Non-root User হিসেবে চালান — Security

USER www-data

Health Check

HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
CMD php-fpm -t || exit 1

EXPOSE 9000

CMD ["php-fpm"]

**Docker Compose — Local Development:**

plaintext
yaml

docker-compose.yml

version: '3.8'

services:
# ─────────────────────────
# Laravel Application
# ─────────────────────────
app:
build:
context: .
dockerfile: Dockerfile
target: dependencies # Development এ dependencies stage
container_name: laravel_app
restart: unless-stopped
working_dir: /var/www/html
volumes:
- .:/var/www/html # Code Mount — Hot Reload
- ./storage:/var/www/html/storage
environment:
- APP_ENV=local
- APP_DEBUG=true
- DB_HOST=mysql
- REDIS_HOST=redis
- QUEUE_CONNECTION=redis
depends_on:
mysql:
condition: service_healthy
redis:
condition: service_healthy
networks:
- laravel_network

# ─────────────────────────
# Nginx Web Server
# ─────────────────────────
nginx:
image: nginx:alpine
container_name: laravel_nginx
restart: unless-stopped
ports:
- "80:80"
- "443:443"
volumes:
- .:/var/www/html
- ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf
- ./docker/nginx/ssl:/etc/nginx/ssl # SSL Certificates
depends_on:
- app
networks:
- laravel_network

# ─────────────────────────
# MySQL Database
# ─────────────────────────
mysql:
image: mysql:8.0
container_name: laravel_mysql
restart: unless-stopped
environment:
MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
MYSQL_DATABASE: ${DB_DATABASE}
MYSQL_USER: ${DB_USERNAME}
MYSQL_PASSWORD: ${DB_PASSWORD}
volumes:
- mysql_data:/var/lib/mysql # Data Persist
- ./docker/mysql/init.sql:/docker-entrypoint-initdb.d/init.sql
ports:
- "3306:3306"
healthcheck:
test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
timeout: 20s
retries: 10
networks:
- laravel_network

# ─────────────────────────
# Redis Cache
# ─────────────────────────
redis:
image: redis:7-alpine
container_name: laravel_redis
restart: unless-stopped
command: redis-server --requirepass ${REDIS_PASSWORD}
volumes:
- redis_data:/data
ports:
- "6379:6379"
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 5s
retries: 5
networks:
- laravel_network

# ─────────────────────────
# Queue Worker
# ─────────────────────────
queue:
build:
context: .
dockerfile: Dockerfile
target: dependencies
container_name: laravel_queue
restart: unless-stopped
command: php artisan queue:work redis \
--sleep=3 \
--tries=3 \
--timeout=90 \
--queue=high-priority,default,low-priority
volumes:
- .:/var/www/html
depends_on:
- app
- redis
networks:
- laravel_network

# ─────────────────────────
# Laravel Scheduler
# ─────────────────────────
scheduler:
build:
context: .
dockerfile: Dockerfile
target: dependencies
container_name: laravel_scheduler
restart: unless-stopped
command: >
sh -c "while true; do
php artisan schedule:run --verbose --no-interaction &
sleep 60
done"
volumes:
- .:/var/www/html
depends_on:
- app
- mysql
networks:
- laravel_network

# ─────────────────────────
# phpMyAdmin (Development)
# ─────────────────────────
phpmyadmin:
image: phpmyadmin/phpmyadmin
container_name: laravel_phpmyadmin
environment:
PMA_HOST: mysql
PMA_PORT: 3306
ports:
- "8080:80"
profiles:
- dev # শুধু Development এ
networks:
- laravel_network

─────────────────────────

Networks & Volumes

─────────────────────────

networks:
laravel_network:
driver: bridge

volumes:
mysql_data:
driver: local
redis_data:
driver: local

**Nginx Config:**

docker
nginx

docker/nginx/default.conf

server {
listen 80;
listen [::]:80;
server_name myapp.com www.myapp.com;

# HTTP → HTTPS Redirect
return 301 https://$server_name$request_uri;

}

server {
listen 443 ssl http2;
server_name myapp.com www.myapp.com;

# SSL Configuration
ssl_certificate     /etc/nginx/ssl/fullchain.pem;
ssl_certificate_key /etc/nginx/ssl/privkey.pem;
ssl_protocols       TLSv1.2 TLSv1.3;
ssl_ciphers         HIGH:!aNULL:!MD5;

root /var/www/html/public;
index index.php;

# Gzip Compression
gzip on;
gzip_types text/plain text/css application/json application/javascript;
gzip_min_length 1000;

# Security Headers
add_header X-Frame-Options "DENY";
add_header X-Content-Type-Options "nosniff";
add_header X-XSS-Protection "1; mode=block";
add_header Referrer-Policy "strict-origin-when-cross-origin";

# Static Files Cache
location ~* \.(jpg|jpeg|png|gif|ico|css|js|woff2)$ {
    expires 30d;
    add_header Cache-Control "public, immutable";
}

# PHP Files
location / {
    try_files $uri $uri/ /index.php?$query_string;
}

location ~ \.php$ {
    fastcgi_pass app:9000;
    fastcgi_index index.php;
    fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
    include fastcgi_params;

    # Timeout Settings
    fastcgi_connect_timeout 60;
    fastcgi_send_timeout 300;
    fastcgi_read_timeout 300;
}

# Sensitive Files Hide করুন
location ~ /\.(env|git|htaccess) {
    deny all;
}

# Max Upload Size
client_max_body_size 20M;

}


---

🔄 **PART 2 — CI/CD Pipeline**

**CI/CD কী?**

yaml
CI = Continuous Integration
→ Code Push করলেই Auto Test চলবে

CD = Continuous Delivery/Deployment
→ Test Pass হলে Auto Deploy হবে

পুরো Flow:
Developer → Git Push → CI Server
↓
[Code Checkout]
↓
[Dependencies Install]
↓
[Code Quality Check]
↓
[Unit Tests Run]
↓
[Integration Tests]
↓
[Docker Image Build]
↓
[Push to Registry]
↓
[Deploy to Staging]
↓
[Smoke Tests]
↓
[Deploy to Production] ✅

**GitHub Actions — CI/CD Pipeline:**

nginx
yaml

.github/workflows/ci-cd.yml

name: Laravel CI/CD Pipeline

on:
push:
branches: [main, develop]
pull_request:
branches: [main]

env:
PHP_VERSION: '8.3'
NODE_VERSION: '20'
DOCKER_IMAGE: ghcr.io/${{ github.repository }}

jobs:
# ─────────────────────────────────
# Job 1: Code Quality Check
# ─────────────────────────────────
code-quality:
name: 🔍 Code Quality
runs-on: ubuntu-latest

steps:
  - name: Checkout Code
    uses: actions/checkout@v4

  - name: Setup PHP
    uses: shivammathur/setup-php@v2
    with:
      php-version: ${{ env.PHP_VERSION }}
      extensions: mbstring, pdo, redis
      coverage: xdebug

  - name: Cache Composer
    uses: actions/cache@v3
    with:
      path: vendor
      key: composer-${{ hashFiles('composer.lock') }}

  - name: Install Dependencies
    run: composer install --no-interaction --prefer-dist

  - name: PHP Code Style Check (Pint)
    run: ./vendor/bin/pint --test

  - name: Static Analysis (PHPStan)
    run: ./vendor/bin/phpstan analyse --level=8

  - name: Security Check
    run: composer audit

# ─────────────────────────────────
# Job 2: Tests
# ─────────────────────────────────
tests:
name: 🧪 Run Tests
runs-on: ubuntu-latest
needs: code-quality

services:
  mysql:
    image: mysql:8.0
    env:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: testing
    options: >-
      --health-cmd="mysqladmin ping"
      --health-interval=10s
      --health-timeout=5s
      --health-retries=3

  redis:
    image: redis:7-alpine
    options: >-
      --health-cmd="redis-cli ping"
      --health-interval=10s

steps:
  - uses: actions/checkout@v4

  - name: Setup PHP
    uses: shivammathur/setup-php@v2
    with:
      php-version: ${{ env.PHP_VERSION }}
      extensions: mbstring, pdo_mysql, redis
      coverage: xdebug

  - name: Install Dependencies
    run: composer install --no-interaction

  - name: Copy .env
    run: |
      cp .env.testing.example .env.testing
      php artisan key:generate --env=testing

  - name: Run Migrations
    run: php artisan migrate --env=testing --force
    env:
      DB_CONNECTION: mysql
      DB_HOST: 127.0.0.1
      DB_DATABASE: testing
      DB_USERNAME: root
      DB_PASSWORD: secret

  - name: Run Unit Tests
    run: |
      php artisan test \
        --parallel \
        --coverage-clover=coverage.xml \
        --min=80
    env:
      DB_CONNECTION: mysql
      DB_HOST: 127.0.0.1
      DB_DATABASE: testing
      DB_USERNAME: root
      DB_PASSWORD: secret
      REDIS_HOST: 127.0.0.1

  - name: Upload Coverage
    uses: codecov/codecov-action@v3
    with:
      file: ./coverage.xml

# ─────────────────────────────────
# Job 3: Build Docker Image
# ─────────────────────────────────
build:
name: 🐳 Build & Push Docker Image
runs-on: ubuntu-latest
needs: tests
if: github.ref == 'refs/heads/main'

steps:
  - uses: actions/checkout@v4

  - name: Set up Docker Buildx
    uses: docker/setup-buildx-action@v3

  - name: Login to GitHub Container Registry
    uses: docker/login-action@v3
    with:
      registry: ghcr.io
      username: ${{ github.actor }}
      password: ${{ secrets.GITHUB_TOKEN }}

  - name: Extract Metadata
    id: meta
    uses: docker/metadata-action@v5
    with:
      images: ${{ env.DOCKER_IMAGE }}
      tags: |
        type=ref,event=branch
        type=semver,pattern={{version}}
        type=sha,prefix=sha-

  - name: Build & Push
    uses: docker/build-push-action@v5
    with:
      context: .
      push: true
      tags: ${{ steps.meta.outputs.tags }}
      labels: ${{ steps.meta.outputs.labels }}
      target: production
      cache-from: type=gha
      cache-to: type=gha,mode=max

# ─────────────────────────────────
# Job 4: Deploy to Staging
# ─────────────────────────────────
deploy-staging:
name: 🚀 Deploy to Staging
runs-on: ubuntu-latest
needs: build
environment: staging

steps:
  - name: Deploy to Staging Server
    uses: appleboy/ssh-action@v1
    with:
      host: ${{ secrets.STAGING_HOST }}
      username: ${{ secrets.STAGING_USER }}
      key: ${{ secrets.STAGING_SSH_KEY }}
      script: |
        cd /var/www/staging
        # নতুন Image Pull করুন
        docker pull ${{ env.DOCKER_IMAGE }}:main

        # Zero-downtime Deploy
        docker-compose up -d --no-deps app
        docker-compose exec -T app php artisan migrate --force
        docker-compose exec -T app php artisan config:cache
        docker-compose exec -T app php artisan route:cache

        # Health Check
        sleep 10
        curl -f http://localhost/health || exit 1

        echo "✅ Staging Deploy সফল!"

# ─────────────────────────────────
# Job 5: Deploy to Production
# ─────────────────────────────────
deploy-production:
name: 🌟 Deploy to Production
runs-on: ubuntu-latest
needs: deploy-staging
environment: production # Manual Approval লাগবে!

steps:
  - name: Blue-Green Deploy to Production
    uses: appleboy/ssh-action@v1
    with:
      host: ${{ secrets.PROD_HOST }}
      username: ${{ secrets.PROD_USER }}
      key: ${{ secrets.PROD_SSH_KEY }}
      script: |
        cd /var/www/production

        # Current Version Backup
        CURRENT=$(docker-compose ps -q app)

        # নতুন Container চালু করুন (Blue-Green)
        docker pull ${{ env.DOCKER_IMAGE }}:main
        docker-compose up -d --no-deps --scale app=2 app

        # Health Check
        sleep 15
        NEW_CONTAINER=$(docker-compose ps -q app | tail -1)
        docker exec $NEW_CONTAINER curl -f http://localhost/health

        # Migration Run করুন
        docker-compose exec -T app php artisan migrate --force

        # Cache Clear
        docker-compose exec -T app php artisan optimize

        # পুরনো Container সরিয়ে দিন
        docker-compose up -d --no-deps --scale app=1 app

        echo "✅ Production Deploy সফল!"

  - name: Notify Slack
    uses: 8398a7/action-slack@v3
    with:
      status: ${{ job.status }}
      text: |
        Production Deploy ${{ job.status }}!
        Commit: ${{ github.sha }}
        By: ${{ github.actor }}
    env:
      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}
    if: always()

**Test Classes — Laravel:**

plaintext
php
// tests/Feature/Api/ProductTest.php
class ProductApiTest extends TestCase
{
use RefreshDatabase, WithFaker;

private User $user;
private string $token;

protected function setUp(): void
{
    parent::setUp();

    // Test User তৈরি করুন
    $this->user  = User::factory()->create();
    $this->token = JWTAuth::fromUser($this->user);
}

/** @test */
public function it_can_list_products(): void
{
    Product::factory()->count(15)->create();

    $response = $this->withToken($this->token)
                     ->getJson('/api/v1/products');

    $response->assertOk()
             ->assertJsonStructure([
                 'data' => [
                     '*' => ['id', 'name', 'price', 'stock']
                 ],
                 'meta' => ['total', 'current_page']
             ])
             ->assertJsonCount(15, 'data');
}

/** @test */
public function it_can_create_product(): void
{
    $category = Category::factory()->create();

    $productData = [
        'name'        => 'Test Product',
        'price'       => 999.99,
        'stock'       => 50,
        'category_id' => $category->id,
    ];

    $response = $this->withToken($this->token)
                     ->postJson('/api/v1/products', $productData);

    $response->assertCreated()
             ->assertJsonFragment(['name' => 'Test Product']);

    $this->assertDatabaseHas('products', [
        'name'  => 'Test Product',
        'price' => 999.99,
    ]);
}

/** @test */
public function it_validates_required_fields(): void
{
    $response = $this->withToken($this->token)
                     ->postJson('/api/v1/products', []);

    $response->assertUnprocessable()
             ->assertJsonValidationErrors(['name', 'price', 'stock']);
}

/** @test */
public function it_returns_404_for_nonexistent_product(): void
{
    $response = $this->withToken($this->token)
                     ->getJson('/api/v1/products/99999');

    $response->assertNotFound();
}

}


---

☸️ **PART 3 — Kubernetes (K8s)**

**Kubernetes কী?**

Kubernetes হলো **Container Orchestration** Platform। অনেক Container কে Manage, Scale, ও Monitor করার Tool।

yaml
Docker = একটা Container চালানো
Kubernetes = হাজারো Container পরিচালনা করা

Kubernetes এর কাজ:
├── Auto Scaling → Traffic বাড়লে Container বাড়াও
├── Self Healing → Container Crash করলে নতুন তৈরি করো
├── Load Balancing → Traffic ভাগ করো
├── Rolling Update → Zero-downtime Deploy করো
└── Service Discovery→ Services খুঁজে পেতে সাহায্য করো

Kubernetes Architecture:
┌─────────────────────────────────────────────┐
│ Control Plane │
│ ┌──────────┐ ┌──────────┐ ┌─────────────┐ │
│ │ API │ │Scheduler │ │ Controller │ │
│ │ Server │ │ │ │ Manager │ │
│ └──────────┘ └──────────┘ └─────────────┘ │
└─────────────────────────────────────────────┘
↓ Manages
┌─────────────────────────────────────────────┐
│ Worker Nodes │
│ ┌────────────────┐ ┌────────────────┐ │
│ │ Node 1 │ │ Node 2 │ │
│ │ ┌──────────┐ │ │ ┌──────────┐ │ │
│ │ │ Pod │ │ │ │ Pod │ │ │
│ │ │(Container│ │ │ │(Container│ │ │
│ │ │+Laravel) │ │ │ │+Laravel) │ │ │
│ │ └──────────┘ │ │ └──────────┘ │ │
│ └────────────────┘ └────────────────┘ │
└─────────────────────────────────────────────┘

**Laravel App এর জন্য Kubernetes Manifests:**

php
yaml

k8s/namespace.yml

apiVersion: v1
kind: Namespace
metadata:
name: laravel-app
labels:
app: laravel

plaintext
yaml

k8s/configmap.yml — Non-sensitive Configuration

apiVersion: v1
kind: ConfigMap
metadata:
name: laravel-config
namespace: laravel-app
data:
APP_ENV: production
APP_DEBUG: "false"
LOG_CHANNEL: stderr
CACHE_DRIVER: redis
QUEUE_CONNECTION: redis
SESSION_DRIVER: redis
DB_CONNECTION: mysql
DB_PORT: "3306"

yaml
yaml

k8s/secret.yml — Sensitive Configuration

apiVersion: v1
kind: Secret
metadata:
name: laravel-secrets
namespace: laravel-app
type: Opaque
data:
# Base64 Encoded Values
APP_KEY: YmFzZTY0ZW5jb2RlZGtleQ==
DB_PASSWORD: c2VjcmV0cGFzc3dvcmQ=
REDIS_PASSWORD: cmVkaXNwYXNz
JWT_SECRET: and0c2VjcmV0a2V5

yaml
yaml

k8s/deployment.yml — Laravel App Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
name: laravel-app
namespace: laravel-app
labels:
app: laravel
version: "1.0"
spec:
replicas: 3 # ৩টা Instance চালাবে
selector:
matchLabels:
app: laravel
strategy:
type: RollingUpdate # Zero-downtime Update
rollingUpdate:
maxSurge: 1 # একটা বেশি তৈরি করো
maxUnavailable: 0 # কোনটা বন্ধ করো না

template:
metadata:
labels:
app: laravel
spec:
containers:
- name: laravel
image: ghcr.io/myapp/laravel:latest
imagePullPolicy: Always
ports:
- containerPort: 9000

      # Environment Variables
      envFrom:
        - configMapRef:
            name: laravel-config
        - secretRef:
            name: laravel-secrets

      # Resource Limits — একটা Pod বেশি Resource নিতে পারবে না
      resources:
        requests:
          memory: "256Mi"
          cpu: "250m"
        limits:
          memory: "512Mi"
          cpu: "500m"

      # Health Checks
      livenessProbe:
        httpGet:
          path: /health
          port: 80
        initialDelaySeconds: 30
        periodSeconds: 10
        failureThreshold: 3

      readinessProbe:
        httpGet:
          path: /health/ready
          port: 80
        initialDelaySeconds: 10
        periodSeconds: 5

      # Lifecycle Hooks
      lifecycle:
        preStop:
          exec:
            command: ["/bin/sh", "-c", "sleep 10"]  # Graceful shutdown

  # Image Pull Secret
  imagePullSecrets:
    - name: ghcr-secret

yaml# k8s/hpa.yml — Auto Scaling
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: laravel-hpa
namespace: laravel-app
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: laravel-app

minReplicas: 3 # সর্বনিম্ন ৩টা
maxReplicas: 20 # সর্বোচ্চ ২০টা

metrics:
# CPU বেশি হলে Scale করুন
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70 # ৭০% CPU হলে নতুন Pod

# Memory বেশি হলে Scale করুন
- type: Resource
  resource:
    name: memory
    target:
      type: Utilization
      averageUtilization: 80

behavior:
scaleUp:
stabilizationWindowSeconds: 60 # ১ মিনিট দেখো
policies:
- type: Pods
value: 3 # একসাথে ৩টা যোগ করো
periodSeconds: 60
scaleDown:
stabilizationWindowSeconds: 300 # ৫ মিনিট দেখো তারপর কমাও
yaml# k8s/queue-worker.yml — Queue Worker Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
name: laravel-queue
namespace: laravel-app
spec:
replicas: 2

template:
spec:
containers:
- name: queue-worker
image: ghcr.io/myapp/laravel:latest
command:
- php
- artisan
- queue:work
- redis
- --sleep=3
- --tries=3
- --timeout=90
- --queue=high-priority,default,low-priority

      envFrom:
        - configMapRef:
            name: laravel-config
        - secretRef:
            name: laravel-secrets

      resources:
        requests:
          memory: "128Mi"
          cpu: "100m"
        limits:
          memory: "256Mi"
          cpu: "250m"

      # Queue Worker Health Check
      livenessProbe:
        exec:
          command:
            - php
            - artisan
            - queue:monitor
            - --max=100
        initialDelaySeconds: 60
        periodSeconds: 60

yaml# k8s/service.yml — Service (Load Balancer)
apiVersion: v1
kind: Service
metadata:
name: laravel-service
namespace: laravel-app
spec:
selector:
app: laravel
ports:
- protocol: TCP
port: 80
targetPort: 80
type: ClusterIP

k8s/ingress.yml — External Access

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: laravel-ingress
namespace: laravel-app
annotations:
# Nginx Ingress Controller
nginx.ingress.kubernetes.io/rewrite-target: /
# SSL Auto-renew
cert-manager.io/cluster-issuer: "letsencrypt-prod"
# Rate Limiting
nginx.ingress.kubernetes.io/rate-limit: "100"
nginx.ingress.kubernetes.io/rate-limit-window: "1m"
spec:
ingressClassName: nginx
tls:
- hosts:
- myapp.com
secretName: myapp-tls
rules:
- host: myapp.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: laravel-service
port:
number: 80

**Kubernetes Commands — Daily Use:**

yaml
bash

─────────────────────────────────────

Deploy করুন

─────────────────────────────────────

kubectl apply -f k8s/ # সব yaml apply করুন
kubectl apply -f k8s/deployment.yml

─────────────────────────────────────

Status দেখুন

─────────────────────────────────────

kubectl get pods -n laravel-app
kubectl get deployments -n laravel-app
kubectl get services -n laravel-app
kubectl get hpa -n laravel-app # Auto Scaling Status

─────────────────────────────────────

Logs দেখুন

─────────────────────────────────────

kubectl logs -f deployment/laravel-app -n laravel-app
kubectl logs -f pod/laravel-app-xxx -n laravel-app

─────────────────────────────────────

Pod এ ঢুকুন

─────────────────────────────────────

kubectl exec -it deployment/laravel-app \
-n laravel-app -- bash

Laravel Commands Run করুন

kubectl exec -it deployment/laravel-app \
-n laravel-app -- php artisan migrate

kubectl exec -it deployment/laravel-app \
-n laravel-app -- php artisan tinker

─────────────────────────────────────

Scale করুন

─────────────────────────────────────

kubectl scale deployment laravel-app \
--replicas=5 -n laravel-app

─────────────────────────────────────

Rolling Update — Zero Downtime

─────────────────────────────────────

kubectl set image deployment/laravel-app \
laravel=ghcr.io/myapp/laravel:v2.0 \
-n laravel-app

kubectl rollout status deployment/laravel-app -n laravel-app

─────────────────────────────────────

Rollback করুন — কিছু ভুল হলে

─────────────────────────────────────

kubectl rollout undo deployment/laravel-app -n laravel-app
kubectl rollout undo deployment/laravel-app \
--to-revision=3 -n laravel-app

─────────────────────────────────────

Resource Usage দেখুন

─────────────────────────────────────

kubectl top pods -n laravel-app
kubectl top nodes

🏥 **PART 4 — Health Check Endpoint**

yaml
php
// routes/api.php
Route::get('/health', [HealthController::class, 'check']);
Route::get('/health/ready', [HealthController::class, 'readiness']);
Route::get('/health/live', [HealthController::class, 'liveness']);

// app/Http/Controllers/HealthController.php
class HealthController extends Controller
{
// Liveness — Container জীবিত আছে?
public function liveness(): JsonResponse
{
return response()->json([
'status' => 'alive',
'timestamp' => now()->toIso8601String(),
]);
}

// Readiness — Traffic নেওয়ার জন্য Ready?
public function readiness(): JsonResponse
{
    $checks = [];
    $healthy = true;

    // Database Check
    try {
        DB::select('SELECT 1');
        $checks['database'] = 'ok';
    } catch (\Exception $e) {
        $checks['database'] = 'fail';
        $healthy = false;
    }

    // Redis Check
    try {
        Redis::ping();
        $checks['redis'] = 'ok';
    } catch (\Exception $e) {
        $checks['redis'] = 'fail';
        $healthy = false;
    }

    // Queue Check
    $failedJobs = DB::table('failed_jobs')->count();
    $checks['queue'] = $failedJobs < 50 ? 'ok' : 'degraded';

    return response()->json([
        'status' => $healthy ? 'ready' : 'not_ready',
        'checks' => $checks,
    ], $healthy ? 200 : 503);
}

}


---


📝 **সংক্ষেপে মনে রাখুন**
**Docker** — আপনার Laravel App এবং সব Dependencies একটা Container এ রাখুন। যেকোনো Server এ একই ভাবে চলবে। Local Development এ `docker-compose` ব্যবহার করুন।
**CI/CD** — GitHub Actions দিয়ে Code Push করলেই Auto Test, Build, Deploy হবে। Test ছাড়া Production এ যাবে না। এতে Human Error কমে।
**Kubernetes** — Production এ অনেক Container Manage করার জন্য। Auto Scaling, Self-healing, Zero-downtime Deploy — সব পাবেন। ছোট Project এ দরকার নেই, বড় হলে অপরিহার্য।
**শেখার ক্রম** — প্রথমে Docker শিখুন → তারপর GitHub Actions দিয়ে CI/CD → পরে Kubernetes।

**_Q:8_** - **Performance Optimization (profiling, load balancing)**
**Answer**: 

⚡ **Performance কেন গুরুত্বপূর্ণ?**
গবেষণা বলছে:

shell
├── 1 সেকেন্ড Delay → ৭% Conversion কমে
├── 3 সেকেন্ড Delay → ৫৩% Mobile User চলে যায়
├── Google Ranking → Page Speed একটা Factor
└── Amazon: ১০০ms → ১% Revenue কমে

আদর্শ Response Time:
├── API Response → < 200ms ✅ খুব ভালো
├── Page Load → < 1s ✅ ভালো
├── Complex Report → < 3s ⚠️ গ্রহণযোগ্য
└── যেকোনো কিছু → > 5s ❌ User চলে যাবে


---

🔍 **PART 1 — Profiling (সমস্যা খুঁজে বের করা)**
**Profiling কী?**
Profiling মানে আপনার অ্যাপের **কোথায় সময় নষ্ট হচ্ছে** সেটা খুঁজে বের করা। Optimize করার আগে অবশ্যই Profile করুন।

php
❌ ভুল পদ্ধতি:
"মনে হচ্ছে Database Slow" → সেটা Optimize করলাম
→ কোনো পার্থক্য নেই!

✅ সঠিক পদ্ধতি:
Profile করুন → সমস্যা খুঁজুন → সেটা Fix করুন
→ আবার Profile করুন → Verify করুন

**Laravel Telescope — Development Profiling:**

plaintext
bash
composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate

plaintext
php
// config/telescope.php
return [
'enabled' => env('TELESCOPE_ENABLED', true),

// কী কী Track করবেন
'watchers' => [
    Watchers\QueryWatcher::class => [
        'enabled' => true,
        'slow'    => 100, // ১০০ms এর বেশি = Slow Query Alert
    ],
    Watchers\RequestWatcher::class => [
        'enabled'          => true,
        'size_limit'       => env('TELESCOPE_RESPONSE_SIZE_LIMIT', 64),
    ],
    Watchers\CacheWatcher::class  => ['enabled' => true],
    Watchers\JobWatcher::class    => ['enabled' => true],
    Watchers\MailWatcher::class   => ['enabled' => true],
    Watchers\ModelWatcher::class  => [
        'enabled' => true,
        'events'  => ['eloquent.created*', 'eloquent.updated*'],
    ],
],

];

// app/Providers/TelescopeServiceProvider.php
class TelescopeServiceProvider extends ServiceProvider
{
public function register(): void
{
Telescope::night(); // Dark Mode

    // Slow Query হলে Alert দিন
    Telescope::filter(function (IncomingEntry $entry) {
        if ($entry->type === EntryType::QUERY) {
            return $entry->content['slow'] ?? false;
        }
        return true;
    });
}

}

**Custom Profiler — Detailed Performance Tracking:**

shell
php
// app/Services/PerformanceProfiler.php
class PerformanceProfiler
{
private array $timings = [];
private array $memories = [];
private float $startTime;
private int $startMemory;

public function start(string $label): void
{
    $this->timings[$label]  = microtime(true);
    $this->memories[$label] = memory_get_usage(true);
}

public function end(string $label): array
{
    $duration    = (microtime(true) - $this->timings[$label]) * 1000;
    $memoryUsed  = memory_get_usage(true) - $this->memories[$label];

    $result = [
        'label'       => $label,
        'duration_ms' => round($duration, 2),
        'memory_kb'   => round($memoryUsed / 1024, 2),
        'slow'        => $duration > 100, // ১০০ms এর বেশি = Slow
    ];

    // Slow Operation Log করুন
    if ($result['slow']) {
        Log::warning("Slow Operation Detected", $result);
    }

    return $result;
}

public function measure(string $label, callable $callback): mixed
{
    $this->start($label);
    $result = $callback();
    $timing = $this->end($label);

    return $result;
}

}

// ব্যবহার
class DashboardController extends Controller
{
public function index(PerformanceProfiler $profiler): JsonResponse
{
$profiler->start('total_dashboard');

    // Products Load
    $products = $profiler->measure('load_products', function () {
        return Product::with(['category', 'brand'])
                      ->where('status', 'active')
                      ->take(20)
                      ->get();
    });

    // Sales Report
    $salesData = $profiler->measure('load_sales', function () {
        return Order::selectRaw('DATE(created_at) as date, SUM(total) as revenue')
                    ->whereBetween('created_at', [
                        now()->subDays(30),
                        now()
                    ])
                    ->groupBy('date')
                    ->get();
    });

    // User Stats
    $userStats = $profiler->measure('load_user_stats', function () {
        return [
            'total'  => User::count(),
            'active' => User::where('last_login_at', '>', now()->subDays(7))->count(),
            'new'    => User::whereDate('created_at', today())->count(),
        ];
    });

    $totalTime = $profiler->end('total_dashboard');

    // Production এ Log করুন
    if (app()->environment('production')) {
        Log::info('Dashboard Performance', [
            'total_ms'   => $totalTime['duration_ms'],
            'user_id'    => auth()->id(),
            'request_id' => request()->header('X-Request-ID'),
        ]);
    }

    return response()->json([
        'products'   => $products,
        'sales'      => $salesData,
        'user_stats' => $userStats,
        '_debug'     => app()->environment('local') ? $totalTime : null,
    ]);
}

}

**Query Profiling — Slow Query খুঁজুন:**

php
php
// app/Providers/AppServiceProvider.php
public function boot(): void
{
if (config('app.debug')) {
// সব Query Log করুন
DB::listen(function (QueryExecuted $query) {
$duration = $query->time; // milliseconds

        // ১০০ms এর বেশি হলে Log করুন
        if ($duration > 100) {
            Log::warning('Slow Query Detected', [
                'sql'        => $query->sql,
                'bindings'   => $query->bindings,
                'duration'   => "{$duration}ms",
                'connection' => $query->connectionName,
                'trace'      => collect(debug_backtrace())
                                ->take(5)
                                ->pluck('file')
                                ->toArray(),
            ]);
        }
    });
}

}

// Query Analysis — EXPLAIN দিয়ে
class QueryAnalyzer
{
public function explain(string $sql, array $bindings = []): array
{
// MySQL EXPLAIN — Query Plan দেখুন
$explained = DB::select("EXPLAIN " . $sql, $bindings);

    $issues = [];

    foreach ($explained as $row) {
        // Full Table Scan — Index নেই!
        if ($row->type === 'ALL') {
            $issues[] = [
                'type'    => 'full_table_scan',
                'table'   => $row->table,
                'rows'    => $row->rows,
                'message' => "⚠️ {$row->table} এ Full Table Scan!
                              Index যোগ করুন।",
            ];
        }

        // No Index Used
        if (empty($row->key)) {
            $issues[] = [
                'type'    => 'no_index',
                'table'   => $row->table,
                'message' => "⚠️ {$row->table} এ কোনো Index ব্যবহার
                              হচ্ছে না।",
            ];
        }
    }

    return [
        'plan'   => $explained,
        'issues' => $issues,
    ];
}

}


---


🚀 **PART 2 — Laravel Specific Optimizations**
**Database Optimization:**

php
php
// ─────────────────────────────────────
// ১. N+1 Query Problem — সবচেয়ে Common
// ─────────────────────────────────────

// ❌ ভুল — ১০১টা Query!
$orders = Order::all(); // 1 Query
foreach ($orders as $order) {
echo $order->user->name; // +1 Query প্রতিটায়
echo $order->product->name; // +1 Query প্রতিটায়
}
// ১০০ Orders = ২০১ Queries!

// ✅ সঠিক — মাত্র ৩টা Query
$orders = Order::with(['user', 'product', 'payment'])
->get();

// ✅ আরো ভালো — দরকারী Field শুধু নিন
$orders = Order::with([
'user:id,name,email', // শুধু এই Fields
'product:id,name,price', // শুধু এই Fields
])
->select(['id', 'user_id', 'product_id', 'total', 'status'])
->get();

// ─────────────────────────────────────
// ২. Select Only Required Columns
// ─────────────────────────────────────

// ❌ ভুল — সব Column নিচ্ছে (SELECT *)
$users = User::all();

// ✅ সঠিক — দরকারী Column শুধু
$users = User::select(['id', 'name', 'email', 'created_at'])->get();

// ─────────────────────────────────────
// ৩. Index Optimization
// ─────────────────────────────────────
class AddPerformanceIndexes extends Migration
{
public function up(): void
{
// Single Column Index
Schema::table('orders', function (Blueprint $table) {
$table->index('status');
$table->index('user_id');
$table->index('created_at');
});

    // Composite Index — একসাথে filter করলে
    Schema::table('orders', function (Blueprint $table) {
        // WHERE user_id = ? AND status = ?
        $table->index(['user_id', 'status']);

        // WHERE status = ? ORDER BY created_at DESC
        $table->index(['status', 'created_at']);
    });

    // Covering Index — Index থেকেই সব Data পাবে, Table যেতে হবে না
    Schema::table('products', function (Blueprint $table) {
        // SELECT id, name, price WHERE category_id = ? AND status = ?
        $table->index(['category_id', 'status', 'id', 'name', 'price']);
    });

    // Full-text Index — Search এর জন্য
    Schema::table('products', function (Blueprint $table) {
        $table->fullText(['name', 'description']);
    });
}

}

// ─────────────────────────────────────
// ৪. Query Chunking — Memory Optimize
// ─────────────────────────────────────

// ❌ ভুল — লক্ষ Row Memory তে Load
$products = Product::all(); // Out of Memory!

// ✅ সঠিক — Chunk করে Process
Product::chunkById(1000, function (Collection $products) {
foreach ($products as $product) {
// Process করুন
$this->processProduct($product);
}
});

// ✅ আরো ভালো — Lazy Collection
Product::lazy(500)->each(function (Product $product) {
$this->processProduct($product);
// Memory: শুধু ৫০০টা একসাথে
});

// ─────────────────────────────────────
// ৫. Aggregate Query Optimization
// ─────────────────────────────────────

// ❌ ভুল — সব Record Load করে Count
$total = Order::where('status', 'completed')->get()->count();

// ✅ সঠিক — DB তেই Count করুন
$total = Order::where('status', 'completed')->count();

// ❌ ভুল — PHP তে Sum করুন
$revenue = Order::where('status', 'completed')
->get()
->sum('total');

// ✅ সঠিক — DB তে Sum করুন
$revenue = Order::where('status', 'completed')->sum('total');

// Multiple Aggregates একসাথে
$stats = Order::where('status', 'completed')
->selectRaw('
COUNT(*) as total_orders,
SUM(total) as total_revenue,
AVG(total) as avg_order_value,
MAX(total) as highest_order,
MIN(total) as lowest_order
')
->first();

**Laravel Cache Optimization:**

php
php
// app/Services/OptimizedProductService.php
class OptimizedProductService
{
// ─────────────────────────────────────
// Multi-level Cache
// ─────────────────────────────────────
private array $localCache = []; // Request-level Cache

public function getProduct(int $id): ?Product
{
    // Level 1: Local Array Cache (সবচেয়ে দ্রুত)
    if (isset($this->localCache["product:{$id}"])) {
        return $this->localCache["product:{$id}"];
    }

    // Level 2: Redis Cache
    $product = Cache::remember(
        "product:{$id}",
        now()->addHours(6),
        // Level 3: Database
        fn() => Product::with(['category:id,name', 'brand:id,name'])
                        ->find($id)
    );

    // Local Cache এ রাখুন
    $this->localCache["product:{$id}"] = $product;

    return $product;
}

// ─────────────────────────────────────
// Batch Cache Loading
// ─────────────────────────────────────
public function getProducts(array $ids): Collection
{
    // Cache থেকে যা আছে নিন
    $cached    = [];
    $missing   = [];

    foreach ($ids as $id) {
        $product = Cache::get("product:{$id}");
        if ($product) {
            $cached[$id] = $product;
        } else {
            $missing[] = $id;
        }
    }

    // শুধু Missing গুলো DB থেকে নিন
    if (!empty($missing)) {
        $products = Product::with(['category', 'brand'])
                           ->whereIn('id', $missing)
                           ->get()
                           ->keyBy('id');

        // Cache এ রাখুন — Pipeline দিয়ে (দ্রুত)
        Redis::pipeline(function ($pipe) use ($products) {
            foreach ($products as $product) {
                $pipe->setex(
                    "product:{$product->id}",
                    3600 * 6,
                    serialize($product)
                );
            }
        });

        $cached = array_merge($cached, $products->toArray());
    }

    return collect($cached);
}

// ─────────────────────────────────────
// Computed Properties Cache
// ─────────────────────────────────────
public function getProductStats(int $productId): array
{
    return Cache::remember(
        "product:{$productId}:stats",
        now()->addMinutes(30),
        function () use ($productId) {
            return [
                'total_sold'   => OrderItem::where('product_id', $productId)
                                           ->sum('quantity'),
                'revenue'      => OrderItem::where('product_id', $productId)
                                           ->sum(DB::raw('quantity * price')),
                'avg_rating'   => Review::where('product_id', $productId)
                                        ->avg('rating'),
                'review_count' => Review::where('product_id', $productId)
                                        ->count(),
                'view_count'   => (int) Redis::get("product:{$productId}:views"),
            ];
        }
    );
}

}

**PHP OpCode Cache & Configuration:**

php
ini
; php.ini / docker/php/php.ini

; ─────────────────────────────────────
; OPcache — PHP Code Cache
; ─────────────────────────────────────
opcache.enable=1
opcache.enable_cli=1
opcache.memory_consumption=256 ; 256MB
opcache.interned_strings_buffer=16 ; 16MB
opcache.max_accelerated_files=20000 ; File Count
opcache.revalidate_freq=0 ; Production: 0 (Never Recheck)
opcache.validate_timestamps=0 ; Production: 0
opcache.save_comments=1
opcache.fast_shutdown=1

; ─────────────────────────────────────
; PHP Configuration
; ─────────────────────────────────────
memory_limit=512M
max_execution_time=60
max_input_time=60
upload_max_filesize=20M
post_max_size=20M

; Realpath Cache
realpath_cache_size=4096K
realpath_cache_ttl=600

php
php
// Laravel Production Optimization Commands
// Deploy এর সময় চালান:

// php artisan optimize — সব একসাথে
// অথবা আলাদা আলাদা:
php artisan config:cache // Config Cache করুন
php artisan route:cache // Route Cache করুন
php artisan view:cache // Blade View Cache করুন
php artisan event:cache // Event Cache করুন

// app/Console/Commands/OptimizeForProduction.php
class OptimizeForProduction extends Command
{
protected $signature = 'app:optimize-production';
protected $description = 'Production Optimization চালান';

public function handle(): void
{
    $this->info('🚀 Optimization শুরু হচ্ছে...');

    $steps = [
        ['php artisan config:cache',  'Config Cache'],
        ['php artisan route:cache',   'Route Cache'],
        ['php artisan view:cache',    'View Cache'],
        ['php artisan event:cache',   'Event Cache'],
        ['php artisan icons:cache',   'Icons Cache'],
    ];

    foreach ($steps as [$command, $label]) {
        $this->call(trim(str_replace('php artisan ', '', $command)));
        $this->line("  ✅ {$label} সম্পন্ন");
    }

    // Cache Warm করুন
    $this->call('cache:warm');
    $this->line("  ✅ Cache Warm সম্পন্ন");

    $this->info('✨ Optimization সম্পন্ন!');
}

}


---

⚖️ **PART 3 — Load Balancing**

**Load Balancing কী?**

php
Load Balancing = Traffic কে একাধিক Server এ ভাগ করা

একটা Server:
[১০০০ Requests] → [Server 1] ← Overwhelmed! 😰

Load Balanced:
[১০০০ Requests] → [Load Balancer]
├── [Server 1] ← ৩৩৩ Requests
├── [Server 2] ← ৩৩৩ Requests
└── [Server 3] ← ৩৩৪ Requests

Load Balancing Algorithms:
├── Round Robin → পালাক্রমে (১→২→৩→১→২→৩)
├── Least Connection → যার Connection কম তাকে দাও
├── IP Hash → Same User → Same Server
├── Weighted → শক্তিশালী Server বেশি পাবে
└── Random → Random Server এ পাঠাও

**Nginx Load Balancer Configuration:**

php
nginx

/etc/nginx/nginx.conf

─────────────────────────────────────

Upstream — Backend Servers Define করুন

─────────────────────────────────────

upstream laravel_app {
# Load Balancing Algorithm
least_conn; # Least Connection — সবচেয়ে কম Busy Server

# Backend Servers
server 10.0.0.1:9000 weight=3;  # শক্তিশালী — বেশি Traffic পাবে
server 10.0.0.2:9000 weight=2;
server 10.0.0.3:9000 weight=1;

# Health Check — Dead Server বাদ দিন
server 10.0.0.4:9000 backup;    # Primary সব Down হলে Backup

# Keepalive Connections — Performance বাড়ায়
keepalive 32;

}

API Servers — আলাদা Upstream

upstream laravel_api {
ip_hash; # Same User → Same Server (Session Consistency)

server 10.0.1.1:9000;
server 10.0.1.2:9000;
server 10.0.1.3:9000;

# Server Down হলে Timeout
server 10.0.1.4:9000 max_fails=3 fail_timeout=30s;

}

─────────────────────────────────────

Rate Limiting Zones

─────────────────────────────────────

limit_req_zone $binary_remote_addr
zone=api_limit:10m # 10MB Memory
rate=100r/m; # প্রতি মিনিটে ১০০ Request

limit_req_zone $binary_remote_addr
zone=login_limit:10m
rate=5r/m; # Login: প্রতি মিনিটে ৫ Request

limit_conn_zone $binary_remote_addr
zone=conn_limit:10m; # Connection Limit

─────────────────────────────────────

Main Server Block

─────────────────────────────────────

server {
listen 443 ssl http2;
server_name myapp.com;

# SSL
ssl_certificate     /etc/nginx/ssl/fullchain.pem;
ssl_certificate_key /etc/nginx/ssl/privkey.pem;
ssl_session_cache   shared:SSL:10m;
ssl_session_timeout 10m;

# ─────────────────────────
# Gzip Compression
# ─────────────────────────
gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_comp_level 6;
gzip_types
    text/plain
    text/css
    text/javascript
    application/json
    application/javascript
    application/xml
    image/svg+xml;

# ─────────────────────────
# Static Files — CDN থেকে
# ─────────────────────────
location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff2|ttf)$ {
    expires 1y;
    add_header Cache-Control "public, immutable";
    add_header Vary "Accept-Encoding";

    # CDN Origin — File না থাকলে S3 থেকে নিন
    try_files $uri @cdn_origin;
}

location @cdn_origin {
    proxy_pass https://myapp-assets.s3.amazonaws.com;
}

# ─────────────────────────
# API Routes
# ─────────────────────────
location /api/ {
    # Rate Limiting
    limit_req zone=api_limit burst=20 nodelay;
    limit_conn conn_limit 10;

    proxy_pass http://laravel_api;
    proxy_http_version 1.1;
    proxy_set_header Connection "";
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Request-ID $request_id;

    # Timeouts
    proxy_connect_timeout 5s;
    proxy_send_timeout 30s;
    proxy_read_timeout 30s;

    # Buffer Settings
    proxy_buffering on;
    proxy_buffer_size 4k;
    proxy_buffers 8 4k;
}

# Login Rate Limiting
location /api/auth/login {
    limit_req zone=login_limit burst=3 nodelay;
    proxy_pass http://laravel_api;
}

# ─────────────────────────
# Web Routes
# ─────────────────────────
location / {
    proxy_pass http://laravel_app;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

# ─────────────────────────
# Health Check
# ─────────────────────────
location /health {
    access_log off;
    proxy_pass http://laravel_app;
}

# ─────────────────────────
# Monitoring
# ─────────────────────────
location /nginx-status {
    stub_status on;
    allow 10.0.0.0/8;    # শুধু Internal IP
    deny all;
}

}

**HAProxy — Advanced Load Balancing:**

ini
haproxy

/etc/haproxy/haproxy.cfg

global
maxconn 50000
log /dev/log local0
user haproxy
group haproxy
daemon

defaults
mode http
log global
option httplog
option dontlognull
option forwardfor
option http-server-close
timeout connect 5s
timeout client 30s
timeout server 30s
retries 3

─────────────────────────────────────

Frontend — User Facing

─────────────────────────────────────

frontend http_front
bind *:80
bind *:443 ssl crt /etc/ssl/myapp.pem

# HTTP → HTTPS Redirect
redirect scheme https if !{ ssl_fc }

# ACL — URL Pattern দিয়ে Route করুন
acl is_api  path_beg /api/
acl is_ws   path_beg /ws/       # WebSocket

# Different Backend এ পাঠান
use_backend api_backend  if is_api
use_backend ws_backend   if is_ws
default_backend web_backend

─────────────────────────────────────

Web Backend

─────────────────────────────────────

backend web_backend
balance leastconn

# Sticky Session — Same User → Same Server
cookie SERVERID insert indirect nocache

# Health Check
option      httpchk GET /health HTTP/1.1\r\nHost:\ localhost
http-check  expect status 200

server web1 10.0.0.1:80 check cookie s1 weight 100
server web2 10.0.0.2:80 check cookie s2 weight 100
server web3 10.0.0.3:80 check cookie s3 weight 100
server web4 10.0.0.4:80 check cookie s4 backup  # Backup

─────────────────────────────────────

API Backend

─────────────────────────────────────

backend api_backend
balance roundrobin
option httpchk GET /health

# Slow Start — নতুন Server ধীরে ধীরে Traffic নেবে
server api1 10.0.1.1:80 check slowstart 30s
server api2 10.0.1.2:80 check slowstart 30s
server api3 10.0.1.3:80 check slowstart 30s

─────────────────────────────────────

Stats Dashboard

─────────────────────────────────────

listen stats
bind *:8404
stats enable
stats uri /stats
stats refresh 30s
stats auth admin:secret_password

📊 **PART 4 — Application Performance Monitoring (APM)**

php
php
// app/Http/Middleware/PerformanceMonitorMiddleware.php
class PerformanceMonitorMiddleware
{
public function handle(Request $request, Closure $next): Response
{
$startTime = microtime(true);
$startMemory = memory_get_usage(true);

    $response = $next($request);

    $duration    = (microtime(true) - $startTime) * 1000;
    $memoryUsed  = (memory_get_usage(true) - $startMemory) / 1024 / 1024;
    $queryCount  = DB::getQueryLog() ? count(DB::getQueryLog()) : 0;
    $peakMemory  = memory_get_peak_usage(true) / 1024 / 1024;

    // Response Header এ দিন — Debug এর জন্য
    if (config('app.debug')) {
        $response->headers->set('X-Response-Time', round($duration, 2) . 'ms');
        $response->headers->set('X-Memory-Usage', round($memoryUsed, 2) . 'MB');
        $response->headers->set('X-Query-Count', $queryCount);
        $response->headers->set('X-Peak-Memory', round($peakMemory, 2) . 'MB');
    }

    // Metrics Collect করুন — Prometheus Format
    $this->recordMetrics([
        'route'       => $request->route()?->getName() ?? 'unknown',
        'method'      => $request->method(),
        'status'      => $response->getStatusCode(),
        'duration_ms' => round($duration, 2),
        'memory_mb'   => round($memoryUsed, 2),
        'queries'     => $queryCount,
    ]);

    // Slow Request Alert
    if ($duration > 2000) { // ২ সেকেন্ড
        Log::warning('Slow Request Detected', [
            'url'         => $request->fullUrl(),
            'method'      => $request->method(),
            'duration_ms' => round($duration, 2),
            'queries'     => $queryCount,
            'user_id'     => auth()->id(),
            'ip'          => $request->ip(),
        ]);
    }

    return $response;
}

private function recordMetrics(array $metrics): void
{
    // Redis এ Metrics Store করুন
    $key = "metrics:" . date('Y-m-d-H');

    Redis::pipeline(function ($pipe) use ($key, $metrics) {
        $pipe->hincrby($key, 'total_requests', 1);
        $pipe->hincrbyfloat($key, 'total_duration', $metrics['duration_ms']);
        $pipe->hincrby($key, "status_{$metrics['status']}", 1);

        // Slow Request Count
        if ($metrics['duration_ms'] > 1000) {
            $pipe->hincrby($key, 'slow_requests', 1);
        }

        // Query Heavy Request
        if ($metrics['queries'] > 20) {
            $pipe->hincrby($key, 'heavy_query_requests', 1);
        }

        $pipe->expire($key, 86400 * 7); // ৭ দিন রাখুন
    });
}

}

// Metrics Dashboard
class MetricsDashboardController extends Controller
{
public function index(): JsonResponse
{
$hours = [];

    for ($i = 23; $i >= 0; $i--) {
        $key  = "metrics:" . now()->subHours($i)->format('Y-m-d-H');
        $data = Redis::hgetall($key);

        $totalRequests = (int) ($data['total_requests'] ?? 0);
        $totalDuration = (float) ($data['total_duration'] ?? 0);

        $hours[] = [
            'hour'            => now()->subHours($i)->format('H:00'),
            'total_requests'  => $totalRequests,
            'avg_response_ms' => $totalRequests > 0
                                  ? round($totalDuration / $totalRequests, 2)
                                  : 0,
            'slow_requests'   => (int) ($data['slow_requests'] ?? 0),
            'status_200'      => (int) ($data['status_200'] ?? 0),
            'status_500'      => (int) ($data['status_500'] ?? 0),
            'error_rate'      => $totalRequests > 0
                ? round(($data['status_500'] ?? 0) / $totalRequests * 100, 2)
                : 0,
        ];
    }

    return response()->json([
        'hourly_metrics' => $hours,
        'summary'        => $this->getSummary($hours),
    ]);
}

private function getSummary(array $hours): array
{
    $totalRequests = array_sum(array_column($hours, 'total_requests'));
    $avgResponse   = collect($hours)
                        ->where('total_requests', '>', 0)
                        ->avg('avg_response_ms');

    return [
        'total_requests_24h' => $totalRequests,
        'avg_response_ms'    => round($avgResponse, 2),
        'peak_hour'          => collect($hours)
                                    ->sortByDesc('total_requests')
                                    ->first()['hour'],
    ];
}

}


---

🗄️ **PART 5 — Database Connection Pooling**

plaintext
php
// config/database.php — Connection Pool Configuration
'mysql' => [
'driver' => 'mysql',
'host' => env('DB_HOST'),
'database' => env('DB_DATABASE'),
'username' => env('DB_USERNAME'),
'password' => env('DB_PASSWORD'),

// Connection Pool Settings
'options' => [
    PDO::ATTR_PERSISTENT         => true,  // Persistent Connection
    PDO::ATTR_EMULATE_PREPARES   => false,
    PDO::MYSQL_ATTR_INIT_COMMAND => "SET time_zone='+06:00'", // Bangladesh
],

// PgBouncer — PostgreSQL Connection Pooler
// docker-compose.yml এ যোগ করুন:
//
// pgbouncer:
// image: edoburu/pgbouncer
// environment:
// DB_HOST: postgres
// DB_PORT: 5432
// MAX_CLIENT_CONN: 1000 # সর্বোচ্চ Client
// DEFAULT_POOL_SIZE: 20 # প্রতি DB ২০ Connection
// POOL_MODE: transaction # Transaction Level Pooling
// ports:
// - "5432:5432"

// app/Services/ConnectionPoolMonitor.php
class ConnectionPoolMonitor
{
public function getStats(): array
{
// Active Connections দেখুন
$connections = DB::select("
SELECT
count(*) as total,
sum(case when command = 'Sleep' then 1 else 0 end) as idle,
sum(case when command != 'Sleep' then 1 else 0 end) as active,
max(time) as max_query_time
FROM information_schema.processlist
WHERE user = ?
", [config('database.connections.mysql.username')]);

    return [
        'total_connections' => $connections[0]->total,
        'idle_connections'  => $connections[0]->idle,
        'active_connections'=> $connections[0]->active,
        'max_query_time_s'  => $connections[0]->max_query_time,
        'pool_usage_pct'    => round(
            $connections[0]->active / max($connections[0]->total, 1) * 100,
            1
        ),
    ];
}

}

🔬 **PART 6 — Performance Testing**

nginx
php
// tests/Performance/ApiPerformanceTest.php
class ApiPerformanceTest extends TestCase
{
/** @test */
public function product_list_api_responds_within_200ms(): void
{
// Seed করুন
Product::factory()->count(100)->create();

    $start = microtime(true);

    $response = $this->getJson('/api/v1/products');

    $duration = (microtime(true) - $start) * 1000;

    $response->assertOk();

    $this->assertLessThan(
        200,
        $duration,
        "Product List API {$duration}ms নিয়েছে। ২০০ms এর মধ্যে হওয়া উচিত।"
    );
}

/** @test */
public function no_n_plus_one_query_on_product_list(): void
{
    Product::factory()->count(20)->create();

    // Query Count Check করুন
    DB::enableQueryLog();

    $this->getJson('/api/v1/products');

    $queryCount = count(DB::getQueryLog());
    DB::disableQueryLog();

    // ৫টার বেশি Query হওয়া উচিত না
    $this->assertLessThanOrEqual(
        5,
        $queryCount,
        "Product List এ {$queryCount} টা Query চললো। N+1 সমস্যা আছে!"
    );
}

}

plaintext
bash

Apache Bench — Simple Load Test

ab -n 1000 -c 100 \
-H "Authorization: Bearer TOKEN" \
https://myapp.com/api/v1/products

Output:

Requests per second: 450 [#/sec]

Time per request: 222 ms

Failed requests: 0

k6 — Advanced Load Testing

k6/load-test.js

import http from 'k6/http';
import { check, sleep } from 'k6';

export let options = {
stages: [
{ duration: '2m', target: 100 }, // Ramp up
{ duration: '5m', target: 100 }, // Stay
{ duration: '2m', target: 200 }, // Spike
{ duration: '5m', target: 200 }, // Stay
{ duration: '2m', target: 0 }, // Ramp down
],
thresholds: {
http_req_duration: ['p(95)<500'], // ৯৫% Request ৫০০ms এর মধ্যে
http_req_failed: ['rate<0.01'], // ১% এর কম Error
},
};

export default function () {
let response = http.get('https://myapp.com/api/v1/products', {
headers: { Authorization: 'Bearer TOKEN' }
});

check(response, {
    'status is 200':          (r) => r.status === 200,
    'response time < 500ms':  (r) => r.timings.duration < 500,
    'has data':               (r) => JSON.parse(r.body).data.length > 0,
});

sleep(1);

}

// চালান:
// k6 run k6/load-test.js


---

📋 **PART 7 — Performance Checklist**

php
php
// app/Console/Commands/PerformanceAudit.php
class PerformanceAudit extends Command
{
protected $signature = 'app:performance-audit';
protected $description = 'Performance সমস্যা খুঁজুন';

public function handle(): void
{
    $this->info('🔍 Performance Audit শুরু হচ্ছে...');
    $issues = [];

    // ১. Cache Check
    if (!config('cache.default') === 'redis') {
        $issues[] = '⚠️ Redis Cache ব্যবহার করুন';
    }

    // ২. Queue Check
    if (config('queue.default') === 'sync') {
        $issues[] = '⚠️ Sync Queue Production এ ব্যবহার করবেন না';
    }

    // ৩. Debug Mode Check
    if (config('app.debug')) {
        $issues[] = '❌ APP_DEBUG=true Production এ বিপজ্জনক!';
    }

    // ৪. Slow Query Check
    $slowQueries = DB::select("
        SELECT query_time, sql_text
        FROM mysql.slow_log
        WHERE query_time > 1
        ORDER BY query_time DESC
        LIMIT 10
    ");

    if (!empty($slowQueries)) {
        $issues[] = '⚠️ ' . count($slowQueries) . 'টা Slow Query পাওয়া গেছে';
    }

    // ৫. Missing Index Check
    $missingIndexes = DB::select("
        SELECT table_name, column_name
        FROM information_schema.columns
        WHERE table_schema = ?
        AND column_name LIKE '%_id'
        AND column_name NOT IN (
            SELECT column_name
            FROM information_schema.statistics
            WHERE table_schema = ?
        )
    ", [config('database.connections.mysql.database'),
        config('database.connections.mysql.database')]);

    if (!empty($missingIndexes)) {
        $issues[] = '⚠️ ' . count($missingIndexes) . 'টা Foreign Key এ Index নেই';
    }

    // Result
    if (empty($issues)) {
        $this->info('✅ কোনো সমস্যা পাওয়া যায়নি!');
    } else {
        $this->error('❌ ' . count($issues) . 'টা সমস্যা পাওয়া গেছে:');
        foreach ($issues as $issue) {
            $this->line("  {$issue}");
        }
    }
}

}
// চালান: php artisan app:performance-audit




---

📝 **সংক্ষেপে মনে রাখুন**
**Profiling আগে, Optimize পরে** — অনুমান না করে আগে Profile করুন, সমস্যা খুঁজুন, তারপর Fix করুন।
**Database** — N+1 Query সবচেয়ে Common সমস্যা। Eager Loading, Index, এবং Select Specific Columns ব্যবহার করুন।

**Cache** — Multi-level Cache ব্যবহার করুন। Local Array → Redis → Database এই ক্রমে।

**Load Balancing** — Nginx বা HAProxy দিয়ে Traffic ভাগ করুন। Least Connection Algorithm বেশিরভাগ ক্ষেত্রে ভালো।

**Testing** — Performance Test CI/CD এ যোগ করুন — যাতে Regression ধরা পড়ে।

**Laravel Specific** — `php artisan optimize` Deploy এ চালান, OPcache Enable করুন, Queue Worker আলাদা রাখুন।

Laravel Reverb & Echo — Interview Q&A

Ruhul Amin Sujon — Sat, 07 Mar 2026 20:10:55 +0000

1️⃣ WebSocket কী? HTTP থেকে কীভাবে আলাদা?

সহজ উত্তর:

কল্পনা করো তুমি তোমার বন্ধুকে চিঠি পাঠাচ্ছো।
HTTP হলো চিঠির মতো:

তুমি → চিঠি পাঠালে → বন্ধু পড়লো → জবাব দিলো → শেষ
(প্রতিবার নতুন চিঠি = নতুন connection)

WebSocket হলো ফোন কলের মতো:

তুমি → ফোন করলে → লাইন খোলা রইলো → যেকোনো সময় কথা বলো
(একবার connect = সবসময় connected)

HTTP:

Browser  →→→ Request →→→  Server
Browser  ←←← Response ←←← Server
(connection বন্ধ!)

WebSocket:

Browser  ←——————————————→  Server
         (সবসময় open থাকে)
         যেকোনো সময় data
         দুইদিক থেকেই যেতে পারে

2️⃣ Laravel Reverb কী? Pusher থেকে কীভাবে আলাদা?
সহজ উত্তর:
Pusher হলো ভাড়া করা ফোন সার্ভিসের মতো — তুমি টাকা দাও, তারা সব manage করে।
Reverb হলো নিজের ফোন টাওয়ার বানানোর মতো — তোমার VPS-এ নিজেই চলে, কাউকে টাকা দিতে হয় না।
Pusher:

তোমার App → Pusher এর Server (বাইরে) → User
            (মাসে টাকা লাগে 💰)

Reverb:

তোমার App → তোমার নিজের Server → User
            (একদম ফ্রি! 🎉)

# Reverb install করা
composer require laravel/reverb
php artisan reverb:install

# চালানো
php artisan reverb:start

3️⃣ Laravel Echo কী?
সহজ উত্তর:
Echo হলো তোমার কানের মতো 👂
Reverb Server কথা বলে — Echo সেটা শোনে এবং তোমার browser-এ দেখায়।

javascript
// Echo ছাড়া (কঠিন):
const socket = new WebSocket('ws://localhost:8080');
socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    if(data.event === 'MessageSent') {
        // কাজ করো
    }
};

// Echo দিয়ে (সহজ):
Echo.private('chat.1')
    .listen('MessageSent', (e) => {
        // সরাসরি কাজ করো! Echo বাকি সব handle করে
    });

Echo আসলে ভেতরে ভেতরে WebSocket connection তৈরি করে, channel subscribe করে, event শোনে — তুমি শুধু .listen() লিখলেই হয়।

4️⃣ Channel কত প্রকার ও কী কী?

সহজ উত্তর:

Channel হলো TV channel-এর মতো। কিছু channel সবাই দেখতে পারে, কিছু channel শুধু subscriber রা।

Public Channel  → যে কেউ দেখতে পারে (খোলা মাঠের মতো)
Private Channel → শুধু logged-in user দেখতে পারে (বাড়ির ভেতরের মতো)
Presence Channel → কে কে online আছে সেটাও জানা যায় (হাজিরা খাতার মতো)
javascript// Public — যে কেউ
Echo.channel('admin-orders')
    .listen('OrderCreated', (e) => { });

// Private — শুধু authenticated user
Echo.private('chat.1')        // chat.{conversation_id}
    .listen('MessageSent', (e) => { });

// Private — শুধু নিজের orders দেখবে
Echo.private('orders.5')      // orders.{user_id}
    .listen('OrderStatusUpdated', (e) => { });
php// channels.php — Private channel এর permission check
Broadcast::channel('chat.{userId}', function ($user, $userId) {
    // এই user কি এই channel দেখার অনুমতি রাখে?
    return (int) $user->id === (int) $userId;
    // true হলে দেখতে পাবে, false হলে পাবে না
});

5️⃣ ShouldBroadcast Interface কী করে?
সহজ উত্তর:
ShouldBroadcast হলো একটা চিহ্নের মতো 🏷️ যেটা Laravel-কে বলে — "এই Event টা শুধু PHP-তে রাখো না, WebSocket দিয়ে browser-এও পাঠাও!"

php
// ShouldBroadcast ছাড়া:
class OrderStatusUpdated  // শুধু PHP জানবে, browser জানবে না
{
    // ...
}

// ShouldBroadcast দিয়ে:
class OrderStatusUpdated implements ShouldBroadcast  // browser-ও জানবে!
{
    // ...
}
php<?php

namespace App\Events;

use App\Models\Orderdetail;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;  // ← এই interface
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Broadcasting\InteractsWithSockets;

class OrderStatusUpdated implements ShouldBroadcast
{
    use Dispatchable;        // broadcast() helper use করতে দেয়
    use InteractsWithSockets; // WebSocket এর সাথে কাজ করতে দেয়
    use SerializesModels;    // Model কে Queue এ safe রাখে

    public Orderdetail $order; // ← public মানে broadcast হবে

    public function __construct(Orderdetail $order)
    {
        $this->order = $order; // order save করো
    }

    public function broadcastOn(): array
    {
        // কোন channel এ পাঠাবো?
        return [
            new PrivateChannel('orders.' . $this->order->user_id)
        ];
    }

    public function broadcastWith(): array
    {
        // কী data পাঠাবো?
        return [
            'order_id' => $this->order->id,
            'status'   => $this->order->status,
        ];
    }
}

6️⃣ `broadcast()` vs `event()` — পার্থক্য কী?

সহজ উত্তর:

event() → শুধু PHP এর ভেতরে কাজ করে (চিৎকার করো, শুধু ঘরের লোক শুনবে)
broadcast() → PHP + WebSocket দিয়ে browser-এও যায় (মাইকে বলো, সবাই শুনবে)

php
// শুধু PHP listeners notify করবে:
event(new OrderStatusUpdated($order));

// PHP + Browser দুটোই notify করবে:
broadcast(new OrderStatusUpdated($order));

// Browser notify করবে কিন্তু যে request করেছে তাকে বাদ দিবে:
broadcast(new OrderStatusUpdated($order))->toOthers();
// (নিজের screen এ duplicate দেখা বন্ধ করতে)

7️⃣ `SerializesModels` Trait কী করে? Bug কেন হয়েছিল?

সহজ উত্তর:

Queue হলো একটা লাইনের মতো 🚶‍♂️🚶‍♂️🚶‍♂️ — কাজগুলো একের পর এক হয়।

SerializesModels Queue-এ Model save করার সময় পুরো Model না রেখে শুধু **ID** রাখে। পরে কাজ করার সময় সেই ID দিয়ে DB থেকে আবার আনে।

Bug হওয়ার কারণ:

public $order;              // ← Type নেই!
__construct($order)         // ← Type নেই!

Queue এ গেলো: {id: 5}     // শুধু ID save হলো
Queue থেকে আসলো: ModelIdentifier{id: 5}  // Model না, শুধু identifier object!
$this->order->user_id      // ❌ ERROR! user_id নেই এই object এ

Fix:

public Orderdetail $order;           // ← Type দিলাম!
__construct(Orderdetail $order)      // ← Type দিলাম!

Queue এ গেলো: {id: 5, class: Orderdetail}
Queue থেকে আসলো: Orderdetail{id:5, user_id:3, status:'Pending'}  // ✅ পুরো Model!
$this->order->user_id      // ✅ কাজ করছে!

8️⃣ Queue কেন দরকার? Broadcast সরাসরি করলে কী হয়?
সহজ উত্তর:
কল্পনা করো তোমার দোকানে ১০০ জন কাস্টমার একসাথে এলো।
Queue ছাড়া: তুমি একা সবাইকে একসাথে serve করতে গেলে — সব ভেঙে পড়বে! 😵
Queue দিয়ে: একটা লাইন তৈরি হবে, একে একে serve হবে — smooth! ✅

php
// Queue ছাড়া broadcast (synchronous):
// User request করলো → broadcast হলো → তারপর response গেলো
// যদি broadcast slow হয় → user অপেক্ষা করবে!

// Queue দিয়ে broadcast (asynchronous):
// User request করলো → response গেলো (fast!) → background এ broadcast হলো
class OrderStatusUpdated implements ShouldBroadcast
{
    // ShouldBroadcast automatically queue use করে
    // .env এ QUEUE_CONNECTION=redis থাকলে Redis queue এ যাবে
}

bash
# Queue worker চালাতে হবে (background এ কাজ করে)
php artisan queue:work redis

# VPS এ Supervisor দিয়ে সবসময় চালু রাখো

9️⃣ Private Channel এ Authentication কীভাবে কাজ করে?

সহজ উত্তর:

Private channel হলো তালা দেওয়া ঘরের মতো 🔒। ঢুকতে হলে চাবি লাগবে।

User browser এ Echo.private('chat.5') লিখলো
        ↓
Echo automatically POST /broadcasting/auth করলো
        ↓
Laravel check করলো — এই user কি chat.5 channel এ ঢুকতে পারবে?
        ↓
channels.php এর callback চললো
        ↓
true → ঢুকতে পারবে ✅  |  false → ঢুকতে পারবে না ❌

php
// routes/channels.php
Broadcast::channel('chat.{userId}', function ($user, $userId) {
    // $user = currently logged in user
    // $userId = channel name এর {userId} part

    // admin সব channel দেখতে পারবে
    // user শুধু নিজেরটা দেখতে পারবে
    return $user->role === 'admin' || (int) $user->id === (int) $userId;
});
php
// bootstrap/app.php এ broadcasting auth route enable করতে হবে
->withRouting(
    channels: __DIR__.'/../routes/channels.php', // ← এটা থাকতে হবে
)

🔟 `broadcastOn()` vs `broadcastWith()` vs `broadcastAs()` — পার্থক্য কী?

সহজ উত্তর:

broadcastOn()   → কোথায় পাঠাবো? (Channel এর নাম)
broadcastWith() → কী পাঠাবো? (Data)
broadcastAs()   → কী নামে পাঠাবো? (Event এর নাম)
phpclass MessageSent implements ShouldBroadcast
{
    public function broadcastOn(): array
    {
        // 📍 কোথায় পাঠাবো?
        return [new PrivateChannel('chat.' . $this->message->conversation_id)];
    }

    public function broadcastWith(): array
    {
        // 📦 কী data পাঠাবো?
        return [
            'id'        => $this->message->id,
            'message'   => $this->message->message,
            'sender_id' => $this->message->sender_id,
            'time'      => $this->message->created_at->format('h:i A'),
        ];
        // শুধু দরকারি data পাঠাও — পুরো Model না
        // কারণ পুরো Model পাঠালে sensitive data যেতে পারে
    }

    public function broadcastAs(): string
    {
        // 🏷️ কী নামে পাঠাবো?
        return 'MessageSent';
        // frontend এ .listen('MessageSent') দিয়ে শুনবো
    }
}

1️⃣1️⃣ .toOthers() কী করে? কখন দরকার?
সহজ উত্তর:
তুমি WhatsApp-এ message পাঠালে — তোমার নিজের screen-এ কি message আবার আসে? না! শুধু অন্যজনের কাছে যায়।
.toOthers() ঠিক সেটাই করে।

php
// toOthers() ছাড়া:
broadcast(new MessageSent($message));
// সবাই পাবে — message পাঠানো user নিজেও পাবে
// ফলে message দুইবার দেখাবে! (একবার JS appendMessage থেকে, একবার Echo থেকে)

// toOthers() দিয়ে:
broadcast(new MessageSent($message))->toOthers();
// message পাঠানো user বাদে বাকি সবাই পাবে ✅
javascript
// Frontend এ নিজের message নিজে append করো:
axios.post('/send', {message: msg})
    .then(res => {
        appendMessage(res.data, true); // নিজে append করলাম
    });

// Echo থেকে শুধু অন্যজনের message নাও:
Echo.private('chat.1')
    .listen('MessageSent', (e) => {
        // toOthers() থাকায় নিজের message এখানে আসবে না
        appendMessage(e.message, false);
    });

1️⃣2️⃣ Redis Queue কীভাবে কাজ করে?

সহজ উত্তর:

Redis Queue হলো একটা To-Do List এর মতো 📝

কাজ আসলো → List এ লিখলো → Worker এসে পড়লো → কাজ করলো → List থেকে কাটলো

broadcast() call হলো
        ↓
Redis এ job save হলো (list এ ঢুকলো)
        ↓
queue:work worker সেটা দেখলো
        ↓
WebSocket এ data পাঠালো
        ↓
Job শেষ (list থেকে কাটলো) ✅

bash
# Redis এ কী আছে দেখো
redis-cli
> KEYS *           # সব keys দেখো
> LLEN queues:default  # queue তে কতটা job আছে
env# .env
QUEUE_CONNECTION=redis   # ← Redis use করবে
REDIS_HOST=127.0.0.1
REDIS_PORT=6379

1️⃣3️⃣ Ajax দুইবার call হওয়ার কারণ কী ছিল?
সহজ উত্তর:
কল্পনা করো তুমি doorbell বাজালে — কিন্তু doorbell এ দুটো বোতাম আছে, দুটোই same কাজ করে। তুমি একটা বাজালেও দুইটাই বাজলো!

javascript
// সমস্যা ছিল:
// ১. Form এর submit event
// ২. Button এর type="submit" — এটাও form submit করে
// = দুইবার submit!

// আরেকটা কারণ:
// @push('scripts') যদি দুইবার load হয়
// তাহলে addEventListener দুইবার attach হয়
// = দুইবার call!
javascript
// Fix:
const form = document.getElementById('chat-form');

// পুরনো সব listener মুছে ফেলো (clone করে)
const freshForm = form.cloneNode(true);
form.parentNode.replaceChild(freshForm, form);

freshForm.addEventListener('submit', function(e) {
    e.preventDefault();      // form submit বন্ধ করো
    e.stopPropagation();     // event bubble বন্ধ করো

    if (sending) return;     // already sending হলে আর করো না
    sending = true;          // flag set করো

    // ... axios call
});

1️⃣4️⃣ Supervisor কী? VPS-এ কেন দরকার?

সহজ উত্তর:

Supervisor হলো একজন Manager এর মতো 👨‍💼

তুমি যদি php artisan queue:work manually চালাও — CMD বন্ধ করলেই সব বন্ধ। কিন্তু Manager (Supervisor) সবসময় দেখছে — কিছু বন্ধ হলে আবার চালু করে দেয়।

তুমি ঘুমাও 😴
        ↓
queue:work crash করলো!
        ↓
Supervisor দেখলো — "আরে বন্ধ হয়ে গেছে!"
        ↓
Supervisor আবার চালু করলো ✅
        ↓
তুমি জানোও না কিছু হয়েছিল

ini; 
/etc/supervisor/conf.d/reverb.conf
[program:reverb]
command=php /var/www/project/artisan reverb:start
autostart=true    ; server start হলে automatically চালু হবে
autorestart=true  ; crash করলে automatically restart হবে
user=www-data

; /etc/supervisor/conf.d/queue.conf
[program:queue]
command=php /var/www/project/artisan queue:work redis
autostart=true
autorestart=true
numprocs=2        ; দুটো worker একসাথে চলবে
user=www-data

1️⃣5️⃣ `ShouldBroadcastNow` vs `ShouldBroadcast` — পার্থক্য কী?

সহজ উত্তর:

ShouldBroadcast     → Queue এ যাবে, একটু পরে পাঠাবে (ডাকযোগে চিঠি)
ShouldBroadcastNow  → Queue bypass করে এখনই পাঠাবে (হাতে হাতে চিঠি)

php
// Queue এ যাবে (recommended for production):
class MessageSent implements ShouldBroadcast { }

// এখনই যাবে, Queue bypass (development/testing এ ভালো):
use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
class MessageSent implements ShouldBroadcastNow { }

কখন কোনটা?

ShouldBroadcast:
✅ Production এ (VPS)
✅ অনেক user থাকলে
✅ Server load কমাতে

ShouldBroadcastNow:
✅ Development এ test করতে
✅ queue:work চালু না থাকলে
✅ Critical notification (এখনই দরকার)

1️⃣6️⃣ Unread Message Count কীভাবে কাজ করে?

সহজ উত্তর:

এটা হলো তোমার WhatsApp-এর লাল badge এর মতো 🔴

নতুন message আসলো
        ↓
Echo .listen() এ ধরা পড়লো
        ↓
JavaScript counter++ করলো
        ↓
Badge এ number দেখালো
        ↓
User click করলো → counter = 0 → badge লুকালো

javascript

let unreadCount = 0;

Echo.private('chat.' + conversationId)
    .listen('MessageSent', (e) => {

        // নিজের message হলে ignore করো
        if (e.message.sender_id === {{ auth()->id() }}) return;

        // Message দেখাও
        appendMessage(e.message, false);

        // Sound বাজাও
        document.getElementById('chatSound').play();

        // Count বাড়াও
        unreadCount++;
        let badge = document.getElementById('unread-badge');
        badge.innerText = unreadCount;
        badge.classList.remove('d-none'); // দেখাও
    });

// User chat খুললে reset করো
function resetUnreadCount() {
    unreadCount = 0;
    document.getElementById('unread-badge').classList.add('d-none'); // লুকাও
}

php
// DB তেও unread count রাখো (page refresh এর পরেও থাকবে)
// messages table এ is_read column
Message::where('conversation_id', $id)
       ->where('sender_id', '!=', auth()->id())
       ->where('is_read', false)
       ->update(['is_read' => true]);

1️⃣7️⃣ .env এ Reverb Config কী মানে?
সহজ উত্তর:

env
# Reverb কোন address এ চলবে?
REVERB_HOST=0.0.0.0      # সব network থেকে connection নেবে
                          # (127.0.0.1 হলে শুধু local থেকে নিতো)

REVERB_PORT=8080          # কোন port এ শুনবে?
                          # (80 হলো HTTP, 443 হলো HTTPS, 8080 হলো custom)

REVERB_SCHEME=https       # http নাকি https?
                          # Production এ সবসময় https

# Frontend (JavaScript) কোথায় connect করবে?
VITE_REVERB_APP_KEY="${REVERB_APP_KEY}"   # চাবি — match করতে হবে
VITE_REVERB_HOST="${APP_URL}"             # কোথায় connect করবে
VITE_REVERB_PORT="${REVERB_PORT}"         # কোন port এ
VITE_REVERB_SCHEME="${REVERB_SCHEME}"     # http/https

javascript
// bootstrap.js এ এই config use হয়:
window.Echo = new Echo({
    broadcaster: 'reverb',
    key: import.meta.env.VITE_REVERB_APP_KEY,    // .env থেকে আসে
    wsHost: import.meta.env.VITE_REVERB_HOST,    // .env থেকে আসে
    wsPort: import.meta.env.VITE_REVERB_PORT,    // .env থেকে আসে
    forceTLS: true,  // https use করবে
});

1️⃣8️⃣ `Nginx` দিয়ে Reverb Proxy কেন দরকার?

সহজ উত্তর:

তোমার বাড়িতে একটাই দরজা (port 443/HTTPS)। কিন্তু ভেতরে দুটো ঘর আছে — একটা website (Laravel), একটা WebSocket (Reverb)।

Nginx হলো দারোয়ানের মতো 💂 — কে কোন ঘরে যাবে সেটা দেখে।

User এর browser
        ↓
https://yourdomain.com (port 443)
        ↓
    Nginx (দারোয়ান)
    /        → Laravel (website)
    /app      → Reverb (WebSocket)

nginx
# Normal website traffic → Laravel
location / {
    try_files $uri $uri/ /index.php?$query_string;
}

# WebSocket traffic → Reverb
location /app {
    proxy_pass http://127.0.0.1:8080;  # Reverb এ পাঠাও
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;      # WebSocket upgrade
    proxy_set_header Connection "Upgrade";       # WebSocket upgrade
}

1️⃣9️⃣ Real-time Order Status কীভাবে কাজ করে — পুরো flow?

সহজ উত্তর:

Admin order status change করলো
            ↓
OrderController → orderStatusUpdate()
            ↓
DB তে status save হলো
            ↓
broadcast(new OrderStatusUpdated($order))
            ↓
Redis Queue তে job গেলো
            ↓
queue:work worker job নিলো
            ↓
Reverb WebSocket server এ পাঠালো
            ↓
User এর browser Echo.private('orders.5') শুনছিলো
            ↓
.listen('OrderStatusUpdated') এ ধরা পড়লো
            ↓
JavaScript DOM update করলো (page refresh ছাড়া!) ✅

javascript
// User এর order page এ:
Echo.private('orders.{{ auth()->id() }}')
    .listen('.OrderStatusUpdated', (e) => {

        // Status badge update করো
        let badge = document.querySelector('#order-' + e.order_id + ' .status-badge');
        if (badge) {
            badge.textContent = e.status;
            // পুরনো class সরাও, নতুন class দাও
            badge.className = 'badge status-' + e.status.toLowerCase();
        }

        // Toast notification দেখাও
        alert('তোমার অর্ডার আপডেট হয়েছে: ' + e.status);
    });

2️⃣0️⃣ Production এ কী কী Check করতে হবে?
সহজ উত্তর:
বাড়ি বানানো শেষ — এখন চেক করো সব ঠিক আছে কিনা 🏠

bash
# ১. Reverb চলছে কিনা দেখো
sudo supervisorctl status glamours-reverb
# RUNNING দেখালে ✅

# ২. Queue worker চলছে কিনা দেখো
sudo supervisorctl status glamours-queue
# RUNNING দেখালে ✅

# ৩. Redis চলছে কিনা দেখো
redis-cli ping
# PONG দেখালে ✅

# ৪. WebSocket connection test করো
# Browser Console এ:
# Echo.connector.pusher.connection.state
# "connected" দেখালে ✅

# ৫. Laravel Config cache করো
php artisan config:cache
php artisan route:cache
php artisan event:cache

# ৬. Failed jobs আছে কিনা দেখো
php artisan queue:failed
# কিছু না দেখালে ✅

# ৭. Log দেখো
tail -f storage/logs/laravel.log
# Error না দেখালে ✅

Production Checklist:
[ ] APP_DEBUG=false
[ ] APP_ENV=production
[ ] QUEUE_CONNECTION=redis
[ ] BROADCAST_CONNECTION=reverb
[ ] Supervisor running (reverb + queue)
[ ] SSL certificate valid (https)
[ ] Nginx proxy configured
[ ] Redis running
[ ] Storage link created
[ ] Config cached

🎯 Quick Summary — একনজরে

WebSocket    = সবসময় open ফোন লাইন
Reverb       = নিজের WebSocket server (ফ্রি!)
Echo         = Browser এ WebSocket শোনার কান
Channel      = TV channel (Public/Private)
ShouldBroadcast = "Browser কেও জানাও" চিহ্ন
broadcast()  = সবাইকে বলো
toOthers()   = নিজে বাদে সবাইকে বলো
Queue        = কাজের লাইন (background এ)
Redis        = দ্রুত Queue storage
Supervisor   = সবসময় চালু রাখার Manager
SerializesModels = Queue এ Model safe রাখে (Type hint দিতে হবে!)

Q_21: which network use Reverb? https network vs Reverb network? explain like as i am 6 years oldMar 6HTTPS vs Reverb Network

Answer:

🏠 একটা গল্প দিয়ে শুরু করি
কল্পনা করো তোমার বাড়িতে দুই ধরনের যোগাযোগ আছে:

১. 📬 চিঠির বাক্স (HTTPS)
   → তুমি চিঠি পাঠাও
   → জবাব আসে
   → তারপর শেষ

২. 📞 টেলিফোন (WebSocket/Reverb)
   → একবার কল করো
   → লাইন সবসময় খোলা থাকে
   → যেকোনো সময় কথা বলো

🌐 HTTPS কীভাবে কাজ করে?

তুমি Browser এ click করলে
         ↓
Browser → "এই page টা দাও" → Server
         ↓
Server → "এই নাও page" → Browser
         ↓
    Connection বন্ধ! 🔒
    (কাজ শেষ, বিদায়!)

Real Example:

তুমি → glamoursworld.com/products চাইলে
         ↓
HTTPS Request গেলো Port 443 দিয়ে
         ↓
Server HTML পাঠালো
         ↓
Connection বন্ধ হয়ে গেলো

পরের বার products এ কিছু add হলে?
তুমি জানবে না! কারণ connection নেই! 😢
তোমাকে আবার refresh করতে হবে।

⚡ WebSocket (Reverb) কীভাবে কাজ করে?

তুমি Browser খুললে
         ↓
Browser → "আমি সবসময় connected থাকতে চাই" → Reverb Server
         ↓
Reverb → "ঠিক আছে, লাইন খোলা রাখলাম" → Browser
         ↓
    Connection সবসময় খোলা! 📞
         ↓
যেকোনো সময় Server → Browser তে data পাঠাতে পারে!
যেকোনো সময় Browser → Server তে data পাঠাতে পারে!

Real Example:

Admin order status "Shipped" করলো
         ↓
Reverb এর লাইন দিয়ে এখনই গেলো
         ↓
তোমার browser এ pop up দেখালো
         ↓
তুমি refresh করোনি, কিন্তু দেখলে! 🎉

🔌 কোন Port দিয়ে কোনটা চলে?

HTTPS  → Port 443  (সব normal website traffic)
HTTP   → Port 80   (insecure, redirect হয় 443 এ)
Reverb → Port 8080 (WebSocket traffic)

কিন্তু তোমার user দুটো port মনে রাখবে কীভাবে?
রাখতে হবে না! Nginx দারোয়ান সব handle করে:

glamoursworld.com      → Port 443 → Nginx → Laravel (Port 9000)
glamoursworld.com/app  → Port 443 → Nginx → Reverb  (Port 8080)

User শুধু glamoursworld.com জানলেই হলো!
Nginx বাকি সব করে। ✅

🔍 Network Tab এ দেখলে কেমন দেখায়?
Browser এ F12 চাপো → Network tab → দেখবে:

HTTPS Requests (সাদা background):
GET  /products          200 OK   (page load)
POST /order-status      200 OK   (form submit)
GET  /api/messages      200 OK   (ajax call)
এগুলো আসে যায়, connection বন্ধ হয়।

WebSocket (হলুদ/নীল background):
WS   /app?appKey=xxx    101 Switching Protocols
↑
এটা একবার connect হয়, তারপর সবসময় open থাকে!
101 মানে "ঠিক আছে, HTTP থেকে WebSocket এ upgrade হলাম"

🏗️ তোমার Project এ কোনটা কীসের জন্য?
┌─────────────────────────────────────────────────────┐
│ glamoursworld.com │
├─────────────────────┬───────────────────────────────┤
│ HTTPS (Port 443) │ WebSocket/Reverb (Port 8080) │
├─────────────────────┼───────────────────────────────┤
│ Page load করা │ Real-time chat message │
│ Form submit করা │ Order status update │
│ Image upload করা │ New order notification │
│ Login/Logout │ Unread message count │
│ Product দেখা │ Sound notification │
│ Order place করা │ Admin badge count │
└─────────────────────┴───────────────────────────────┘

📡 Protocol পরিবর্তন কীভাবে হয়?
শুরুতে HTTPS দিয়ে হাত মেলানো হয়:

Browser: "নমস্কার! আমি WebSocket connection চাই"
         GET /app HTTP/1.1
         Upgrade: websocket          ← "upgrade করতে চাই"
         Connection: Upgrade
         Sec-WebSocket-Key: abc123   ← "এই চাবি দিয়ে চিনবো"

Reverb:  "ঠিক আছে! চলো upgrade করি"
         HTTP/1.1 101 Switching Protocols  ← "101 = রাজি!"
         Upgrade: websocket
         Connection: Upgrade

এরপর থেকে:
Browser ←————— WebSocket ——————→ Reverb
        (আর HTTP না, এখন WS protocol)

🔒 WSS vs WS — কোনটা ব্যবহার করবে?

WS  = ws://  = WebSocket (insecure, HTTP এর মতো)
WSS = wss:// = WebSocket Secure (secure, HTTPS এর মতো)

ঠিক যেমন:
HTTP  → HTTPS (তালা দেওয়া)
WS    → WSS   (তালা দেওয়া)

Production VPS এ সবসময় WSS ব্যবহার করো:

.env:
REVERB_SCHEME=https   ← এটা দিলে WSS automatically use হবে

bootstrap.js:
window.Echo = new Echo({
    forceTLS: true,   ← WSS force করো (wss://)
});

🎯 এক লাইনে Summary

HTTPS  = চিঠি  📬 (পাঠাও, জবাব পাও, শেষ)
Reverb = ফোন   📞 (একবার connect, সবসময় কথা বলো)

দুটো একসাথে চলে, দুটো আলাদা কাজ করে।
তোমার project এ দুটোই দরকার! ✅

Q_22: whisper & listenForWhisper কী?
Answer:

🗣️ একটা গল্প দিয়ে শুরু করি
কল্পনা করো তুমি ক্লাসরুমে আছো।

😤 জোরে কথা বলা (broadcast):
"আমি message পাঠালাম!"
→ সবাই শুনলো
→ Teacher ও শুনলো
→ Database এ লেখা হলো
→ সবাই জানলো

🤫 কানে কানে বলা (whisper):
"আমি টাইপ করছি..."
→ শুধু পাশের বন্ধু শুনলো
→ Teacher জানলো না
→ Database এ কিছু লেখা হলো না
→ এক সেকেন্ড পরে ভুলে গেলো

whisper হলো কানে কানে বলার মতো! 🤫

🔍 Code Line by Line বোঝো
Part 1: User টাইপ করলে whisper পাঠাও

javascript
// User যখন message box এ কিছু লিখতে শুরু করে
messageInput.addEventListener('input', () => {
    // ← 'input' মানে keyboard এ যেকোনো key press হলে

    // কানে কানে বলো (whisper) — শুধু ওই channel এর লোক শুনবে
    Echo.private('chat.' + conversationId)
    //   ↑ এই specific conversation এর channel এ
        .whisper('typing', {
        //        ↑ event এর নাম 'typing'
            user_id: {{ auth()->id() }},
            // ↑ আমি কে? (যাতে নিজের typing indicator না দেখাই)
            typing: true
            // ↑ "হ্যাঁ, আমি এখন টাইপ করছি"
        });

Part 2: ১ সেকেন্ড পরে টাইপিং বন্ধ

javascript    
// আগের timer বাতিল করো
    clearTimeout(typingTimer);
    // ↑ কেন? user প্রতিটা key press এ timer reset করবে
    // "a" চাপলো → 1 sec timer শুরু
    // "b" চাপলো → আগের timer বাতিল, নতুন timer শুরু
    // "c" চাপলো → আবার বাতিল, নতুন timer
    // শেষ key press এর ১ সেকেন্ড পরে চলবে ↓

    typingTimer = setTimeout(() => {
    //            ↑ ১ সেকেন্ড পরে এই কাজ করো

        Echo.private('chat.' + conversationId)
            .whisper('typing', {
                user_id: {{ auth()->id() }},
                typing: false
                // ↑ "আমি এখন আর টাইপ করছি না"
            });

    }, 1000);
    //  ↑ 1000 millisecond = 1 second

Part 3: অন্যজনের typing শোনো

javascript
Echo.private('chat.' + conversationId)
    .listenForWhisper('typing', (e) => {
    //                 ↑ 'typing' whisper আসলে এই কাজ করো

        // নিজের typing indicator দেখাবো না!
        if(e.user_id === {{ auth()->id() }}) return;
        //  ↑ যদি আমি নিজেই পাঠিয়ে থাকি → ignore করো

        let indicator = document.getElementById('typing-indicator');
        // ↑ HTML এ এই element টা ধরো (যেখানে "typing..." দেখাবে)

        if(e.typing){
            indicator.style.display = 'block'; // দেখাও ✅
        }else{
            indicator.style.display = 'none';  // লুকাও ✅
        }
    });

🆚 `whisper` vs `broadcast` — পার্থক্য কী?

                    whisper          broadcast
                    ───────          ─────────
Database save?      ❌ না            ✅ হ্যাঁ
Queue use করে?      ❌ না            ✅ হ্যাঁ
Server এ যায়?       ❌ না*           ✅ হ্যাঁ
শুধু Channel এ?     ✅ হ্যাঁ         ✅ হ্যাঁ
Speed?              ⚡ অনেক দ্রুত   🐢 একটু ধীর
কাজ?               ক্ষণস্থায়ী      স্থায়ী

*whisper সরাসরি Reverb এর মাধ্যমে peer-to-peer যায়, Laravel server এ যায় না!

⚡ কেন whisper ব্যবহার করলাম?

Typing indicator এর জন্য broadcast ব্যবহার করলে কী হতো?

User "Hello" লিখলো = 5 টা key press
         ↓
5 টা broadcast() call
         ↓
5 টা Queue job
         ↓
5 টা Database query (না হলেও server এ যেতো)
         ↓
Server এ অনেক চাপ! 😵

Whisper ব্যবহার করলে:

User "Hello" লিখলো = 5 টা key press
         ↓
5 টা whisper (সরাসরি WebSocket এ)
         ↓
0 টা Queue job
         ↓
0 টা Database query
         ↓
Server এ কোনো চাপ নেই! 😎✅

🎬 Real-life Flow দেখো

Rafi টাইপ করছে → Mim দেখছে

Rafi এর screen:               Mim এর screen:
─────────────                 ──────────────
[Hello world...]              [          ]
     ↓                             ↓
whisper('typing',{true})  →→→ listenForWhisper
     ↓                             ↓
                              "Rafi is typing..." 💬

Rafi ১ সেকেন্ড থামলো:
whisper('typing',{false}) →→→ listenForWhisper
                               typing indicator লুকালো 🙈

🎯 এক লাইনে Summary

**whisper**         = কানে কানে বলা 🤫
                  (database নেই, server নেই, শুধু channel এ)

**listenForWhisper** = কান পেতে শোনা 👂
                  (whisper আসলে সাথে সাথে react করো)

**কেন দরকার?**     = Typing indicator এর মতো
                  ক্ষণস্থায়ী জিনিসের জন্য
                  যেটা save করার দরকার নেই
                  কিন্তু real-time দেখাতে হবে ✅

**_Q_23_**: websocket, পিএইচপি তে কিভাবে চেক করতে পারি? কোন নেটওয়ার্ক ব্যবহার করে? Networking  এর সাথে websocket সম্পর্ক কি?

**Answer**: 

1️⃣ **WebSocket আসলে কী?**

WebSocket হলো একটি **persistent (সবসময় খোলা)** full-duplex communication protocol।

👉 মানে:

- Client ↔ Server **একই connection এ দু’দিকেই data পাঠাতে পারে**
- HTTP এর মতো বারবার request–response লাগে না

উদাহরণ:

- Chat app
- Live notification
- Real-time dashboard
- Facebook feed update

2️⃣ **WebSocket কোন Network / Protocol ব্যবহার করে?**
🔹 **Layer অনুযায়ী দেখি (Networking view)**

Application Layer → WebSocket (ws / wss)
Transport Layer → TCP
Network Layer → IP


👉 **WebSocket = TCP এর উপর তৈরি**
👉 **UDP না**, কারণ reliability দরকার

🔹 **Port ব্যবহার**

![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/prj8a5pks8z4pqdbd1sd.png)



👉 `wss://` = WebSocket over TLS (HTTPS-এর মতো secure)

3️⃣ **HTTP vs WebSocket (Networking পার্থক্য)**

![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0vqq7t7f3toejdgcv0ui.png)



📌 WebSocket **HTTP দিয়ে শুরু হয়**, কিন্তু পরে HTTP না থাকে।

4️⃣ **WebSocket কীভাবে শুরু হয়? (Handshake)**

👉 শুরু হয় HTTP request দিয়ে:

GET /chat HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: xyz
Sec-WebSocket-Version: 13


Server reply দেয়:

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade


✔ এরপর connection পুরোপুরি WebSocket হয়ে যায়

---

5️⃣ **PHP তে WebSocket কিভাবে চেক করবো?**
✅ **Method–1: Request Header দেখে (PHP)**

if (
isset($_SERVER['HTTP_UPGRADE']) &&
strtolower($_SERVER['HTTP_UPGRADE']) === 'websocket'
) {
echo "This is a WebSocket request";
}

✅ **Method–2: fsockopen দিয়ে low-level check**

$socket = fsockopen("tcp://127.0.0.1", 6001, $errno, $errstr, 2);

if ($socket) {
echo "WebSocket server is running";
} else {
echo "WebSocket server not reachable";
}

✅ **Method–3: Laravel WebSocket (Recommended)**

যদি Laravel ব্যবহার করো:

php artisan websockets:serve


Browser console:

let ws = new WebSocket("ws://localhost:6001");
ws.onopen = () => console.log("Connected");

6️⃣ **PHP দিয়ে WebSocket Server কিভাবে বানানো হয়?**

👉 Pure PHP দিয়ে সাধারণত Ratchet ব্যবহার করা হয়।

composer require cboden/ratchet

use Ratchet\MessageComponentInterface;
use Ratchet\ConnectionInterface;

class Chat implements MessageComponentInterface {
public function onMessage(ConnectionInterface $conn, $msg) {
$conn->send("Server got: $msg");
}
}


📌 Laravel এ সাধারণত:

- **Laravel WebSockets**
- **Pusher**
- **Socket.IO (Node.js backend)**

7️⃣ **Networking এর সাথে WebSocket এর সম্পর্ক কী?**

👉 সংক্ষেপে:

বিষয় সম্পর্ক
TCP WebSocket TCP ব্যবহার করে
Port 80 / 443
Firewall HTTPS এর মতো pass করে
Latency কম
Stateful Yes
OSI Layer Application layer




👉 WebSocket হলো **Networking-এর real-time application layer protocol**

8️⃣ **Real-Life Analogy** 🧠

- HTTP = দরজায় নক (প্রতি বার knock)
- WebSocket = ফোন কল (একবার ধরলে কথা চলতেই থাকে)

---

🧠 **Interview-Ready Answer (Short)**

> WebSocket is a full-duplex, persistent protocol built on top of TCP.
> It starts with an HTTP handshake, then upgrades to ws/wss.
> In PHP, WebSocket requests can be detected via Upgrade headers or by running a WebSocket server like Ratchet or Laravel WebSockets.
> It’s tightly related to networking as it operates at the application layer over TCP/IP.

🚀 Laravel Developer হিসেবে Salary বাড়ানোর ৮টি Skill

Ruhul Amin Sujon — Mon, 23 Feb 2026 14:09:16 +0000

1️⃣ System Design & Scalable Architecture

Mid-level থেকে senior developer হওয়ার সবচেয়ে বড় skill।

শিখতে হবে:

Monolithic vs Microservices
Caching strategy
Load balancing
Queue system
Database scaling

Example interview question:

“How would you design a SaaS system for 1 million users?”

💰 Salary impact: +20K to +40K

2️⃣ Advanced Laravel Architecture

Laravel শুধু CRUD না, advanced concepts দরকার।

Important topics:

Service Layer
Repository Pattern
SOLID principles
Laravel events & listeners
Job queues

3️⃣ Microservices & API Architecture

Modern SaaS system mostly API-based।

Learn:

API gateway
JWT auth
Rate limiting
Service-to-service communication

Tools:

Laravel + Node / Go services

4️⃣ Queue & Background Processing

High scale system এ এটা mandatory।

Learn:

Redis queues
Laravel Horizon
RabbitMQ
Kafka (optional)

Example:

Email queue
Notification system
Report generation

5️⃣ DevOps Basics

Developer হিসেবে DevOps জানলে salary দ্রুত বাড়ে।

Learn:

Docker
CI/CD (GitHub Actions / GitLab)
Linux server management
Nginx
deployment automation

6️⃣ Cloud Platforms

বাংলাদেশের product companies এখন cloud ব্যবহার করছে।

Learn:

AWS
DigitalOcean
Cloud storage
CDN

Important services:

EC2
S3
RDS
Cloudflare

7️⃣ AI / LLM Integration

এটা এখন super hot skill (2025–2026)।

আপনি already advantage এ আছেন কারণ আপনি:

ChatGPT API project করেছেন

আরও শিখতে পারেন:

OpenAI API
RAG systems
Vector database
AI chatbot
AI automation tools

8️⃣ Modern Frontend (React / Next.js)

Laravel backend + modern frontend developer হলে demand বেশি।

Learn:

React
Next.js
API integration
state management

Full stack developer হলে salary দ্রুত বাড়ে।

⭐ আপনার Current Strength

আপনার CV অনুযায়ী strong areas:

✔ Laravel backend
✔ REST API
✔ Redis caching
✔ SaaS / ERP systems
✔ Government projects
✔ AI API integration

মানে আপনি already mid-level developer।

Projects

🚀 Laravel Developer এর ৫টি Powerful Side Project

1️⃣ AI SaaS Application (ChatGPT Integration)

আপনি যেহেতু ইতিমধ্যে ChatGPT API ব্যবহার করেছেন, এটাকে proper SaaS project বানাতে পারেন।

Features:

AI chatbot
document summarizer
AI content generator
conversation history
subscription system

Tech stack:

Laravel
OpenAI API
Redis queue
MySQL
React / Vue

Recruiter impression:

“Candidate understands AI integration and SaaS architecture.”

2️⃣ Multi-Tenant SaaS Platform

SaaS companies এই skill খুব value দেয়।

Example:

SaaS CRM / Project Management Tool

Features:

Multi-tenant architecture
Role & permission system
Team workspace
Subscription billing
API access

Important concept:

tenant database / tenant middleware
queue jobs
API tokens

Recruiter impression:

“Candidate understands scalable SaaS systems.”

3️⃣ Real-Time Notification System

Large systems এ real-time architecture খুব important।

Example:

live notifications
chat system
live order updates

Tech:

Laravel
WebSockets
Redis
Pusher / Socket.io

Recruiter impression:

“Candidate knows event-driven architecture.”

4️⃣ High-Performance REST API System

একটা scalable API platform বানাতে পারেন।

Example:

Ecommerce API

Features:

JWT authentication
rate limiting
API versioning
caching (Redis)
queue jobs

Extra:

API documentation (Swagger)

Recruiter impression:

“Candidate understands backend engineering.”

5️⃣ Microservices Laravel System

এটা করলে recruiter খুব impressed হয়।

Example:

System structure:

Auth Service
Order Service
Payment Service
Notification Service

Tech:

Laravel Lumen / Laravel
Docker
Redis queue
API gateway

Recruiter impression:

“Candidate understands distributed architecture.”

⭐ Bonus (আপনার জন্য best project)

আপনার experience অনুযায়ী এই projectটা করলে সবচেয়ে powerful হবে:

AI Customer Support SaaS

Features:

ChatGPT AI support bot
ticket system
knowledge base
vector search
admin analytics dashboard

এটা করলে আপনি AI + SaaS developer হিসেবে position করতে পারবেন।

📈 CV-তে Recruiter কী দেখতে চায়

Strong portfolio project হলে CV-তে লিখবেন:

Built an AI-powered SaaS platform using Laravel and OpenAI API supporting real-time chat, queue processing, and scalable API architecture.

এই ধরনের line recruiter খুব পছন্দ করে।

Roadmap

🚀 Laravel Developer Salary Jump Roadmap (৬ মাস)
🟢 Month 1 — Advanced Laravel Architecture

লক্ষ্য: CRUD developer → professional backend engineer

শিখুন:

Service Layer Architecture
Repository Pattern
SOLID Principles
Laravel Events & Listeners
Laravel Jobs & Queues

Practice project:
👉 Existing project refactor করে clean architecture বানান।

🟢 Month 2 — API Engineering & Security

Modern system mostly API-first।

শিখুন:

REST API best practices
JWT Authentication
API Rate Limiting
API Versioning
API documentation (Swagger / Postman)

Practice project:
👉 Production-ready REST API বানান।

🟢 Month 3 — Performance & Scaling

এই skill senior developerদের differentiate করে।

শিখুন:

Redis caching
Laravel Horizon
Database indexing
Query optimization
Queue workers

Example:
👉 High traffic ecommerce API simulation

🟢 Month 4 — DevOps & Deployment

Developer হিসেবে DevOps জানলে salary দ্রুত বাড়ে।

শিখুন:

Docker

Linux server management
Nginx configuration
CI/CD (GitHub Actions)
Zero downtime deployment

Practice:
👉 Project Docker container করে deploy করুন।

🟢 Month 5 — AI Integration (Hot Skill)

আপনি already advantage এ আছেন।

Deep dive করুন:

OpenAI API
AI chat systems
RAG (Retrieval Augmented Generation)
Vector database (Pinecone / Weaviate)

Project:
👉 AI SaaS chatbot platform

🟢 Month 6 — System Design

Senior developer interview এর সবচেয়ে important skill।

শিখুন:

System design basics
Monolith vs Microservices
Event-driven architecture
Load balancing
CDN / caching strategy

Practice:

👉 Design system like:

Uber backend
WhatsApp chat system
SaaS platform architecture

📈 Expected Result After 6 Months

আপনি তখন comfortable হবেন:

✔ Scalable backend systems
✔ SaaS architecture
✔ AI integrations
✔ DevOps deployment
✔ System design interviews

এগুলো থাকলে বাংলাদেশে salary range সাধারণত:

💰 80K – 120K+

⭐ Extra Tip (Recruiter Trick)

আপনার GitHub / portfolio তে এই ৩টা project থাকলে interview chance অনেক বাড়ে:

1️⃣ AI SaaS project
2️⃣ Scalable API platform
3️⃣ Multi-tenant SaaS system

Avoid Mistakes

বাংলাদেশে অনেক Laravel developer ৩–৪ বছর experience থাকার পরেও ৪০K–৫০K salary-তেই আটকে থাকে। সাধারণত এর পেছনে কিছু common mistake থাকে। নিচে ৫টা সবচেয়ে বড় mistake দিলাম—যেগুলো avoid করলে career growth অনেক দ্রুত হয়।

🚫 Laravel Developer Career Growth থামিয়ে দেয় এমন ৫টি Mistake

1️⃣ শুধু CRUD Developer হয়ে থাকা

অনেক developer শুধু এই কাজগুলো করে:

controller
model
migration
basic CRUD
CRUD module
Admin panel
Form submit
Basic API

কিন্তু modern backend এ লাগে:

system design
queue processing
caching
scalable architecture

Recruiter তখন ভাবে:

“Candidate junior level mindset।”

“এই developer শুধু feature implement করে, system design করতে পারে না।”

✔ Solution
Advanced Laravel concepts শিখুন:

Service layer
Repository pattern
Queue systems
Event-driven architecture

2️⃣ Production System কীভাবে Scale হয় না জানা

অনেক developer জানে না:

Redis caching
queue workers
database indexing
load optimization

যখন interview এ জিজ্ঞেস করে:

“1 million users হলে system কীভাবে handle করবেন?”

তখন answer দিতে পারে না।

3️⃣ GitHub / Portfolio না থাকা

বাংলাদেশে অনেক developer এর:

GitHub empty
real project নেই
code sample নেই

Recruiter তখন evaluate করতে পারে না।

Strong developer এর usually থাকে:

open-source repo
SaaS side project
API project

2️⃣ API Architecture না শেখা

Modern applications প্রায় সবই API-first।

অনেক Laravel developer শুধু blade-based system বানায়।

কিন্তু market demand:

REST API
API security
JWT auth
API rate limiting

✔ Solution
কমপক্ষে ৩টা production-level API project বানান।

5️⃣ New Technology শেখে না

অনেক Laravel developer stuck থাকে:

PHP + jQuery
basic Laravel

কিন্তু market demand এখন:

React / Next.js
Docker
Cloud
AI integration
Microservices

যারা এগুলো শেখে না তারা career plateau তে চলে যায়।

3️⃣ DevOps না জানা

বাংলাদেশে অনেক developer শুধু coding জানে।

কিন্তু company চায়:

server deployment
Docker
CI/CD
Linux server management

DevOps skill থাকলে developer more valuable হয়ে যায়।

4️⃣ Strong Portfolio না থাকা

অনেক developer CV-তে লিখে:

“Worked on ERP system”

কিন্তু recruiter proof দেখতে চায়:

GitHub project
live SaaS product
technical architecture

✔ Solution
কমপক্ষে:

2 strong GitHub project
1 SaaS project
1 API platform

5️⃣ Job Switch না করা

বাংলাদেশে salary growth বেশি হয় job change করলে।

Typical pattern:

Years Same Company Salary
1 year 25K
2 years 35K
3 years 45K

কিন্তু job switch করলে:

Experience Salary
3 years 60K – 90K

✅ Good News (আপনার জন্য)

আপনার CV অনুযায়ী আপনি already কিছু advantage এ আছেন:

✔ REST API
✔ Redis caching
✔ SaaS / ERP systems
✔ Government projects
✔ AI API integration

মানে আপনি stuck developer category তে না।

⭐ Bonus Career Advice

আপনার profile অনুযায়ী এই ৩টা skill add করলে fastest growth হবে:

1️⃣ System design
2️⃣ AI integration
3️⃣ DevOps (Docker + CI/CD)

আপনি already ChatGPT API project করেছেন—এটা market এ big advantage।

high-demand tech stack

🚀 ২০২৬ সালে Laravel Developerদের জন্য High-Demand Tech Stack

1️⃣ Backend Core Stack

এটা আপনার main foundation।

Tech:

PHP 8+
Laravel 10/11
REST API / GraphQL
JWT / OAuth authentication

Why important

Modern SaaS, fintech, ERP — সব জায়গায় API-first architecture চলছে।

2️⃣ Modern Frontend Stack

Laravel developer হলে এখন frontend skill থাকাও গুরুত্বপূর্ণ।

Most demanded:

React.js
Next.js
Vue.js
Tailwind CSS

Best combo:

Laravel API + React / Next.js frontend

এটা SaaS product company গুলো খুব পছন্দ করে।

3️⃣ Database & Caching Stack

High-performance backend এর জন্য।

Tech:

MySQL / PostgreSQL
Redis
Elasticsearch (optional)

Use cases:

caching
search engine
session storage
queue system

4️⃣ Queue & Background Processing

High-scale systems এ mandatory।

Tech:

Redis queues
Laravel Horizon
RabbitMQ / Kafka (advanced)

Example:

email queue
notification system
report generation

5️⃣ DevOps & Deployment

এটা জানলে salary খুব দ্রুত বাড়ে।

Tech:

Docker
Linux server
Nginx
CI/CD (GitHub Actions / GitLab)

Deployment stack example:

Laravel + Docker + Nginx + CI/CD pipeline

6️⃣ Cloud Platforms

Product companies এখন mostly cloud use করে।

Most used:

AWS
DigitalOcean
Cloudflare
S3 storage

Important services:

EC2
RDS
CDN
Object storage

7️⃣ AI Integration (2025–2026 Hot Skill)

এটা এখন developer market এ game changer।

Tech:

OpenAI API
AI chatbot systems
RAG architecture
vector database

Example features:

AI support bot
AI content generator
AI automation tools

আপনি যেহেতু ChatGPT API project করেছেন, এটা already big advantage।

⭐ Most Powerful Stack Combination (Bangladesh Market)

২০২৬ সালে সবচেয়ে demanded stack:

Laravel + React/Next.js
Redis + Queue
Docker + AWS
AI API integration

এই stack থাকলে developer salary সাধারণত:

💰 80K – 150K+

📈 আপনার Current Stack vs Market

আপনার CV অনুযায়ী already আছে:

✔ Laravel
✔ Vue / React
✔ REST API
✔ Redis
✔ SaaS / ERP projects

Add করলে সবচেয়ে লাভ হবে:

Docker
AWS
System design
AI SaaS project

Laravel IQ - Level 1 - Part 5

Ruhul Amin Sujon — Sat, 31 Jan 2026 17:08:29 +0000

প্রশ্ন ১: আমার ম্যানুবার ডাটাবেইজ এ সেভ আছে & cache use করে লোড করাই। এখন আমি আবার নতুন একটা মেনুবার এড করলাম, ওই লগিন করা ইউজার রিয়েল টাইমে কিভাবে মেনুটা পাবে? best approach টা বলো আমাকে?

উত্তর:

🧠 Problem Recap (তুমি যা বলছো)

✅ Menu DB তে সেভ করা
✅ Performance এর জন্য cache থেকে menu load করছো
❓ এখন নতুন menu add করলে, 👉 already login করা user কীভাবে** real-time** নতুন menu পাবে?

🎯 Short Answer (Interview-Ready):

Best approach হলো:
👉 Cache Invalidation + Event/Broadcast (WebSocket) + Smart Frontend Refresh
সব ক্ষেত্রে full real-time socket দরকার হয় না — requirement অনুযায়ী solution নিতে হয়।

✅ Best Approaches (Priority অনুযায়ী)

আমি তোমাকে ৩টা practical approach দেবো — production-ready।

🥇 Approach 1: Cache Invalidation + Next Request Reload (MOST COMMON & BEST)
🔹 Concept:

Menu add/update/delete হলে menu cache clear
User এর next request এ menu আবার DB থেকে load হয়ে cache হবে
Simple, scalable, safe

🔹 Backend Example:

// MenuController.php
public function store(Request $request)
{
    Menu::create($request->all());


    Cache::forget('menus'); // 🔥 cache invalidate
}

🔹 Menu Load:

$menus = Cache::remember('menus', 3600, function () {
    return Menu::active()->get();
});

🔹 Result:

User page reload / API call করলেই নতুন menu পাবে
90% SaaS, ERP, Admin panel এ এটাই ব্যবহার হয়

✅ Pros

Simple
No extra infra
Highly scalable

❌ Cons

Strict “real-time” না (reload লাগবে)

👉 If requirement না বলে “instant live without reload” → THIS IS BEST

🥈 Approach 2: Event + Broadcast (Real-Time without reload)

যদি requirement হয়:

“Admin menu add করলেই user instant menu পাবে (no refresh)”

তাহলে 👇

🔹 Flow:

Admin adds menu
 → MenuCreated Event
 → Cache clear
 → Broadcast event
 → Frontend listens
 → Menu API refetch

🔹 Backend: Event

event(new MenuUpdated());

🔹 Event Class:

class MenuUpdated implements ShouldBroadcast
{
    public function broadcastOn()
    {
        return new Channel('menu-channel');
    }
}

🔹 Frontend (Vue / JS example):

Echo.channel('menu-channel')
    .listen('MenuUpdated', () => {
        fetchMenus(); // API call করে নতুন menu আনবে
    });

🔹 Result:

User login অবস্থাতেই menu auto update
No reload needed

✅ Pros

Real-time UX
Modern feel

❌ Cons

Redis / WebSocket setup
Complexity বেশি

👉 Use when:
Dashboard / POS / Live admin systems

🥉 Approach 3: Cache Versioning (Very Smart & Scalable)

🔥 এটা senior-level trick

🔹 Concept:

Menu cache key এর সাথে version যুক্ত করো
Menu update হলে version change
Old cache auto-ignore হয়ে যাবে

🔹 Example:

$version = Cache::get('menu_version', 1);


$menus = Cache::remember("menus_v{$version}", 3600, function () {
    return Menu::all();
});

🔹 Menu update হলে:

Cache::increment('menu_version');

🔹 Result:

No need to flush cache
Zero race condition
Highly scalable

✅ Pros

Clean architecture
Multi-server safe

❌ Cons

একটু advanced thinking লাগে

👉 Use when:
Large-scale SaaS / multi-tenant system

❌ What NOT to do (Bad Practice)

🚫 Cache::flush()
🚫 Every second polling
🚫 Force logout users
🚫 DB hit on every request

🎯 Interview Killer Answer (1–2 lines):

Menu update হলে আমি menu cache invalidate করি।
Real-time দরকার হলে Laravel Event + Broadcast ব্যবহার করে frontend কে menu refetch করতে বলি।
Large system হলে cache versioning strategy ব্যবহার করি।

প্রশ্ন 2: Production এ redis configure কিভাবে?
i. shared hosing (c-panel),
ii. VPS ,
iii. AWS & after production configure ,
.env তে কি কি change করতে হবে?

উত্তর:

✅ Production-এ Redis Configure করার পূর্ণ গাইড (Laravel)

আমি ৩টা environment আলাদা করে বলবো:

1️⃣ Shared Hosting (cPanel)
2️⃣ VPS (DigitalOcean / Contabo / Vultr ইত্যাদি)
3️⃣ AWS (EC2 / ElastiCache)

তারপর বলবো 👉 .env-এ কী কী change করতে হবে

🧠 আগে বুঝে নাও: Laravel Redis কেন ব্যবহার করে?

Laravel Redis ব্যবহার করে:

Cache
Queue
Session
Broadcast
Rate limiting

🟡 i. Shared Hosting (cPanel) এ Redis Configure

⚠️ Reality check:
সব shared hosting এ Redis support করে না।

✅ Prerequisites:

Hosting provider Redis enable করে দিতে হবে
PHP Redis extension (phpredis) enabled থাকতে হবে

🔹 Step 1: cPanel → Redis Enable

cPanel → Select PHP Version
Extensions → ✔️ redis
Save

🔹 Step 2: Laravel .env config

CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis


REDIS_CLIENT=phpredis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

📌 Shared hosting এ সাধারণত:

REDIS_HOST=127.0.0.1
Password থাকে না

🔹 Step 3: config clear

php artisan config:clear
php artisan cache:clear

❌ Limitation (Shared Hosting):

Redis restart control নেই
Performance limited
Queue worker চালানো যায় না

👉 Small project / cache only হলে OK

🟢 ii. VPS-এ Redis Configure (BEST PRACTICE)

এইটা সবচেয়ে common & professional setup।

🔹 Step 1: Redis Install (Ubuntu)

sudo apt update
sudo apt install redis-server

🔹 Step 2: Redis Secure & Optimize

sudo nano /etc/redis/redis.conf

Change:

supervised systemd
bind 127.0.0.1
requirepass strongpassword

Restart:

sudo systemctl restart redis
sudo systemctl enable redis

Check:

redis-cli ping
# PONG

🔹 Step 3: PHP Redis Extension Install

sudo apt install php-redis
sudo systemctl restart php8.2-fpm

🔹 Step 4: Laravel .env

CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis


REDIS_CLIENT=phpredis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=strongpassword
REDIS_PORT=6379

🔹 Step 5: Queue Worker (Production MUST)

php artisan queue:work --daemon

Or better:

sudo supervisorctl start laravel-worker

✅ VPS Advantages:

Full control
Best performance
Redis + Queue + Horizon সব possible

👉 Recommended for SaaS / ERP / API

🔵 iii. AWS-এ Redis Configure

AWS-এ ২টা option থাকে:

🔹 Option A: Redis inside EC2 (VPS-like)

Exactly VPS-এর মতোই setup
👉 Not recommended for production scale

🔹 Option B: AWS ElastiCache (BEST PRACTICE)**

✔️ Managed Redis
✔️ Auto scaling
✔️ High availability

🔹 Step 1: Create ElastiCache Redis

AWS Console → ElastiCache
Engine: Redis
Node type: cache.t3.micro (small)
Enable Auth Token

🔹 Step 2: Security Group

Allow Redis port 6379
Only from EC2 private IP

🔹 Step 3: Laravel .env

CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis


REDIS_CLIENT=phpredis
REDIS_HOST=redis-cluster.xxxxxx.cache.amazonaws.com
REDIS_PASSWORD=auth-token
REDIS_PORT=6379

📌 Important:
EC2 + Redis must be in same VPC

✅ AWS Redis Benefits:

Zero maintenance
Auto failover
Production-grade

👉 Enterprise / high traffic app এর জন্য BEST

🔧 Production .env – Common Redis Config

CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis


REDIS_CLIENT=phpredis
REDIS_HOST=
REDIS_PASSWORD=
REDIS_PORT=6379

Optional (multiple DB):

REDIS_DB=0
REDIS_CACHE_DB=1

❌ Common Mistakes (Interview Trap ⚠️)

🚫 Cache::flush() production এ
🚫 Redis open to public IP
🚫 .env change করে config clear না করা
🚫 Queue worker না চালানো

🏆 Which Setup Should You Choose?

🎯 Interview-Ready One-Line Answer:

Production-এ Redis configure করতে আমি environment অনুযায়ী setup করি।
VPS-এ Redis server install করে .env-এ cache, session, queue redis করি।
AWS-এ ElastiCache ব্যবহার করি scalability ও reliability এর জন্য।

প্রশ্ন 3: আমার ১ মতো মিলিয়ন ডাটা আছে। আমাকে একটা পেজেই দেখাতে হবে। chunk ব্যবহার করা ভালো হবে নাকি ajax ব্যবহার করা ভালো হবে?

উত্তর:

সংক্ষিপ্ত উত্তর 👉 chunk না, AJAX (pagination / lazy loading / infinite scroll)
এখন বিস্তারিতভাবে কেন সেটা বুঝিয়ে দিচ্ছি।

🔥 মূল কথা (Very Important)

👉 ১ মিলিয়ন ডাটা এক পেজে একসাথে দেখানো বাস্তবে অসম্ভব ও ভুল ডিজাইন
এটা করলে:

Server memory crash হতে পারে
Browser hang করবে
User experience ভয়াবহ হবে

🧩 Chunk vs AJAX – আসলে কোনটা কী কাজে?
🔹 Chunk কী?

chunk() ব্যবহার হয় server-side data processing এর জন্য
👉 UI-তে ডাটা দেখানোর জন্য না

User::chunk(1000, function ($users) {
    foreach ($users as $user) {
        // process data (email, export, update)
    }
});

✔ Memory safe
❌ Frontend rendering-এর জন্য নয়

🔹 AJAX কী?

AJAX ব্যবহার হয় frontend-এ ধাপে ধাপে data লোড করার জন্য

fetch('/users?page=2')

✔ Fast UI
✔ Scalable
✔ Real-world solution

✅ সঠিক Solution Architecture (Best Practice)
Option 1: Pagination (সবচেয়ে recommended)

$users = User::paginate(50);

Frontend:

{{ $users->links() }}

✔ Simple
✔ SEO friendly
✔ Production safe

Option 2: AJAX Pagination (Modern UX)

$users = User::paginate(50);
return response()->json($users);

JS দিয়ে page load

✔ Smooth experience
✔ No page reload

Option 3: Infinite Scroll / Lazy Load

$users = User::cursorPaginate(50);

✔ Facebook / YouTube style
✔ Large data friendly

🚀 Extra Optimization (1 million data হলে MUST)
✅ Index ব্যবহার

CREATE INDEX idx_created_at ON users(created_at);

✅ cursorPaginate (pagination এর চেয়ে fast)

User::cursorPaginate(100);

✅ Select only required columns

User::select('id','name')->cursorPaginate(50);

🧠 Interview Ready Answer:

> chunk() server-side heavy processing-এর জন্য, আর ১ মিলিয়ন ডাটা UI-তে দেখানোর জন্য AJAX pagination / lazy loading ব্যবহার করা উচিত।

🏁 Final Recommendation (Your Case)

👉 AJAX + cursor pagination + proper indexing
👉 কখনোই ১ মিলিয়ন row এক পেজে render করবে না

প্রশ্ন 4: কিন্তু ক্লায়েন্টের রিকয়ারমেন্ট হলো ফেসবুক পোস্টের মতো স্ক্রল করে ডেটা লোড করা। অর্থাৎ, স্ক্রল করার সাথে সাথে অনবরত পোস্ট লোড হতে থাকবে এবং প্রদর্শিত হবে। তারা এই লিস্টের ক্ষেত্রেও ঠিক একই জিনিস চাচ্ছে। আমি এটি কীভাবে করতে পারি?

উত্তর:

এটা আসলে Facebook-style Infinite Scroll requirement 👍
এই ক্ষেত্রে AJAX + Cursor Pagination ব্যবহার করাই একমাত্র production-safe solution।
আমি পুরো flow + Laravel + JS example দিয়ে বুঝিয়ে দিচ্ছি।

🧠 Core Idea (Facebook যেভাবে করে)

❌ একবারে ১ মিলিয়ন ডাটা লোড না
✅ প্রথমে অল্প ডাটা
✅ Scroll করলে পরের ডাটা
✅ User বুঝতেই পারে না যে backend-এ pagination চলছে

🏗️ Architecture (High Level)

Browser scroll
   ↓
AJAX request (cursor / page)
   ↓
Laravel API
   ↓
Database (indexed)
   ↓
JSON response
   ↓
Append to DOM

✅ Step 1: Database Optimization (Must)

👉 যেই column দিয়ে order করবে, সেটাতে index লাগবে

CREATE INDEX idx_id ON posts(id);

Facebook-style feed সাধারণত:

ORDER BY id DESC

✅ Step 2: Laravel Controller (cursorPaginate)

👉 paginate() না, cursorPaginate() ব্যবহার করো (১ মিলিয়নের জন্য best)

public function posts(Request $request)
{
    $posts = Post::select('id', 'title', 'body')
        ->orderByDesc('id')
        ->cursorPaginate(10);

    return response()->json($posts);
}

📌 কেন cursorPaginate?

OFFSET ব্যবহার করে না
Large dataset-এ fast
Memory efficient

✅ Step 3: Route

Route::get('/posts', [PostController::class, 'posts']);

✅ Step 4: Frontend HTML

<div id="post-container"></div>
<div id="loader">Loading...</div>

✅ Step 5: JavaScript (Infinite Scroll)

let nextPageUrl = '/posts';

function loadPosts() {
    if (!nextPageUrl) return;

    fetch(nextPageUrl)
        .then(res => res.json())
        .then(data => {
            data.data.forEach(post => {
                document.getElementById('post-container')
                    .insertAdjacentHTML(
                        'beforeend',
                        `<div class="post">
                            <h4>${post.title}</h4>
                            <p>${post.body}</p>
                        </div>`
                    );
            });

            nextPageUrl = data.next_page_url;
            document.getElementById('loader').style.display = 'none';
        });
}

window.addEventListener('scroll', () => {
    if (
        window.innerHeight + window.scrollY >= document.body.offsetHeight - 200
    ) {
        document.getElementById('loader').style.display = 'block';
        loadPosts();
    }
});

// First load
loadPosts();

🔥 Result

✔ First page loads fast
✔ Scroll করলে auto load
✔ User মনে করে সব এক পেজেই আছে
✔ Backend safe even with 1M rows

⚠️ Important Production Tips
1️⃣ Throttle AJAX calls

let loading = false;
if (loading) return;
loading = true;

2️⃣ Stop when no data

if (!nextPageUrl) {
    loader.innerText = 'No more posts';
}

3️⃣ Cache (Optional)

Cache::remember("posts_{$cursor}", 30, fn() => $posts);

🧠 Interview-Ready Explanation:

Facebook-style infinite scroll করতে AJAX + cursor pagination ব্যবহার করা হয়।
এতে large dataset efficiently load হয়, offset query এড়ানো যায়, এবং smooth UX পাওয়া যায়।

🏁 Final Recommendation (Exactly your case)

✅ AJAX
✅ cursorPaginate()
✅ Indexed column
✅ Infinite scroll JS

প্রশ্ন 5: “How would you design a SaaS system for 1 million users?” or “1 million users হলে system কীভাবে handle করবেন?”

উত্তর:
Strong answer structure:

Load Balancer

Nginx / AWS Load Balancer

Multiple App Servers

Laravel app multiple instances

Database optimization

indexing
read replicas

Caching

Redis

Queue system

background jobs

CDN

static files via Cloudflare

Example short answer:

“I would scale the system using load balancers, multiple Laravel app servers, Redis caching, queue workers for background jobs, optimized database indexing, and CDN for static assets.”

Q_06: Laravel এ csrf token কীভাবে জেনারেট হয় & ডাটাবেইজ এর কোথায় সেভ হয় & কিভাবে টোকেন ভ্যালিডেশন করে?

Answer:

1️⃣ CSRF Token কী?

CSRF (Cross-Site Request Forgery) attack থেকে বাঁচার জন্য Laravel প্রতিটি state-changing request (POST, PUT, DELETE, PATCH) এ একটি secret token ব্যবহার করে।

2️⃣ CSRF Token কীভাবে Generate হয়?

👉 CSRF token তৈরি হয় session start হওয়ার সময়।

**কোথায়?**
Illuminate\Session\Middleware\StartSession

কীভাবে?

Laravel একটি random 40 character string তৈরি করে
এটি session-এর মধ্যে _token নামে সেট করে

csrf_token(); // helper function

এটা আসলে:

session()->token();

3️⃣ CSRF Token কোথায় Save হয়?
❌ Database এ নয়

👉 CSRF token কখনো database এ save হয় না

✅ Save হয়:

Session storage এ

Session driver অনুযায়ী location বদলায়:

Session Driver      Token কোথায় থাকে
file (default)      storage/framework/sessions/
database        sessions table
redis               Redis memory
cookie              Encrypted cookie

👉 কিন্তু token সবসময় session data-এর অংশ

4️⃣ Form / Request এ Token কীভাবে যায়?
Blade form:

<form method="POST">
    @csrf
</form>

HTML এ রূপ নেয়:

<input type="hidden" name="_token" value="random_string">

AJAX Request:

headers: {
  'X-CSRF-TOKEN': document
    .querySelector('meta[name="csrf-token"]')
    .getAttribute('content')
}

5️⃣ CSRF Validation কীভাবে হয়?

👉 Validation হয় এই middleware দিয়ে:

App\Http\Middleware\VerifyCsrfToken

Validation Flow:

1️⃣ Request আসে
2️⃣ Middleware _token বা X-CSRF-TOKEN পড়ে
3️⃣ Session এর _token এর সাথে compare করে
4️⃣ Match হলে → request allow
5️⃣ Match না হলে → 419 Page Expired

6️⃣ CSRF Check কোন Request এ হয়?

HTTP Method CSRF
GET         ❌
HEAD            ❌
OPTIONS         ❌
POST            ✅
PUT         ✅
PATCH           ✅
DELETE          ✅

7️⃣ Token Regenerate কবে হয়?

User logout করলে
session()->regenerateToken() call করলে
New session তৈরি হলে

session()->regenerateToken();

8️⃣ CSRF Skip করা যায়?

protected $except = [
    'webhook/*',
];

⚠️ শুধু trusted route এ

🧠 Interview-Ready Summary:

Laravel CSRF token session start হওয়ার সময় generate হয়, session-এ _token হিসেবে store থাকে, database এ save হয় না, এবং VerifyCsrfTokenmiddleware request token এর সাথে session token match করে validate করে।

🔥 Real-Life Analogy:

CSRF token =
🎟️ Cinema ticket stub
Ticket ছাড়া ভিতরে ঢোকা যাবে না—even যদি তুমি বাইরে থেকে ডাকো।

Q:6: আমার ২টা টেবিলের ডাটা জয়েন করে দেখাইতে হবে।কিভাবে পারফরম্যান্স অপ্টিমাইজড করে দেখাইতে পারি? & O(log n) আনতে পারি?

Answer:
1️⃣ বাস্তবতা আগে বুঝি (Important Truth)

👉 SQL JOIN কখনোই pure O(log n) হয় না পুরো result-এর জন্য
কিন্তু ✔ lookup / filtering অংশ O(log n) করা যায় index দিয়ে।

👉 Interview-style কথা:

“We can achieve O(log n) lookup using proper indexing, but overall join result depends on dataset size.”

2️⃣ ধরো ২টা টেবিল
users
|id | name
orders

| id | user_id | amount |

SELECT u.name, o.amount
FROM users u
JOIN orders o ON o.user_id = u.id
WHERE u.id = 10;

3️⃣ 🚀 Performance Optimization (MOST IMPORTANT)
✅ 1. Join Column-এ Index (Mandatory)

ALTER TABLE users ADD PRIMARY KEY (id);
ALTER TABLE orders ADD INDEX idx_user_id (user_id);

👉 এখন lookup হবে B-Tree index → O(log n)

✅ 2. Filter FIRST, Join LATER

❌ খারাপ:

SELECT *
FROM users u
JOIN orders o ON o.user_id = u.id;

✔ ভালো:

SELECT u.name, o.amount
FROM users u
JOIN orders o ON o.user_id = u.id
WHERE u.id = 10;

👉 ছোট dataset join হয়

✅ 3. Select only required columns

SELECT u.name, o.amount

❌ SELECT *

✅ 4. Proper Join Type ব্যবহার
Situation Join
Mandatory relation INNER JOIN
Optional relation LEFT JOIN

INNER JOIN fast হয়

✅ 5. Covering Index (Advanced)

CREATE INDEX idx_orders_user_amount
ON orders(user_id, amount);

👉 DB table read না করেই index থেকে data পায়

4️⃣ Laravel Level Optimization
❌ N+1 Problem (Worst)

$users = User::all();
foreach ($users as $user) {
   $user->orders;
}

✅ Eager Loading

User::with('orders:id,user_id,amount')
    ->where('id', 10)
    ->get();

✅ Join Instead of Eloquent Relation (Heavy data হলে)

DB::table('users')
    ->join('orders', 'orders.user_id', '=', 'users.id')
    ->where('users.id', 10)
    ->select('users.name', 'orders.amount')
    ->get();

5️⃣ EXPLAIN ব্যবহার করো (Very Important)

EXPLAIN SELECT ...

Check করো:

type → ref / eq_ref (BEST)
key → index used
rows → low number

6️⃣ Cache Layer (Real World)

Cache::remember('user_orders_10', 60, function () {
   return DB::table(...)
});

👉 Read-heavy হলে massive boost

7️⃣ O(log n) Practical Explanation
Layer Complexity
Index lookup O(log n)
Join result build O(k)
Network transfer O(k)

👉 Lookup O(log n), Output O(k) ← এটাই বাস্তব

🧠 Interview-Ready Final Answer:

Proper indexing on join & filter columns ensures O(log n) lookup. Using selective WHERE, INNER JOIN, covering index, eager loading / join query, and EXPLAIN ensures optimized join performance. Full join output cannot be pure O(log n), but lookup can be.

🏁 Checklist (Use this in real project)

✅ Indexed join column
✅ Filter early
✅ Select only required columns
✅ Avoid N+1
✅ Use EXPLAIN
✅ Cache read-heavy join

Q_7: ১. আমার ২ টা আলাদা আলাদা ডাটাবেইজ আছে, দুই ডাটাবেইজ থেকে জয়েন করে ডাটা আনতে হবে, কিভাবে করতে পারি??
২. মাইক্রোসার্ভিস কি & কেন ব্যবহার করা হয়?
১ নং প্রশ্নের সাথে ২ নং প্রশ্নের সম্পর্ক কি?

Answer:

দুইটা আলাদা Database থেকে JOIN কিভাবে করবো?

এখানে ২টা আলাদা scenario আছে—এগুলো আলাদা করে বুঝতে হবে।

🔹 Case–1: একই DB Server, আলাদা Database (MySQL same server)

ধরা যাক:

Database-1 → user_db
Database-2 → order_db
দুটোই একই MySQL server-এ

👉 তখন cross-database JOIN সম্ভব।

SQL Example:

SELECT u.name, o.amount
FROM user_db.users u
JOIN order_db.orders o ON o.user_id = u.id;

✔ Works
✔ Fast (index থাকলে)
✔ Production-safe (monolith system)

Laravel Example:

DB::select("
  SELECT u.name, o.amount
  FROM user_db.users u
  JOIN order_db.orders o ON o.user_id = u.id
");

📌 শর্ত:

Same DB host
Same DB engine (MySQL ↔ MySQL)

❌ Case–2: আলাদা DB Server (Different Host / Microservice DB)

ধরা যাক:

User DB → Server A
Order DB → Server B

👉 SQL JOIN অসম্ভব ❌

কারণ:

Database engine একে অপরকে চেনে না
Network boundary আছে

✅ Solution (Application-level JOIN)

$users = DB::connection('user_db')
            ->table('users')
            ->get()
            ->keyBy('id');

$orders = DB::connection('order_db')
            ->table('orders')
            ->get();

$result = $orders->map(function ($order) use ($users) {
    return [
        'user' => $users[$order->user_id]->name ?? null,
        'amount' => $order->amount
    ];
});

⚠️ বড় data হলে:

Pagination
Filter first
Cache

2. Microservice কী & কেন ব্যবহার করা হয়?
🔹 Microservice কী?

Microservice হলো architecture যেখানে:

বড় application কে ছোট ছোট independent service এ ভাগ করা হয়
প্রতিটা service এর:
নিজস্ব codebase
নিজস্ব database
আলাদা deploy

Example:

User Service → user_db
Order Service → order_db
Payment Service → payment_db

🔹 কেন Microservice ব্যবহার করা হয়?
কারণ ব্যাখ্যা

Scalability                     আলাদা service আলাদা scale
Fault isolation                    এক service down → সব down না
Team independence              আলাদা team আলাদা service
Tech flexibility               Node + Go + PHP mix
Fast deployment                    Independent release

১ নং প্রশ্নের সাথে ২ নং প্রশ্নের সম্পর্ক কী?

👉 এইটাই সবচেয়ে গুরুত্বপূর্ণ অংশ 👇

🔗 Direct Relationship

Situation                 Join possible?
Monolith (same DB server)   ✅ Yes
Microservice (separate DB)  ❌ No

Microservice Rule:

❌ Never JOIN across service databases

🧠 তাহলে Microservice এ ডাটা কিভাবে আনে?
✅ API Composition (Most common)

Client
 ↓
Backend API
 ↓
User Service API
 ↓
Order Service API
 ↓
Merge data

Example:

$user = Http::get('user-service/api/users/10');
$orders = Http::get('order-service/api/orders?user_id=10');

👉 Join হয় code level-এ, DB level-এ না

✅ Event-Driven (Advanced)

Order created
Event publish
User service local cache update

✅ Data Duplication (Read model)

Read-optimized table
CQRS pattern

🧠 Interview-Ready Final Answer:

Same DB server হলে cross-database JOIN করা যায়।
Microservice architecture-এ প্রতিটা service এর আলাদা database থাকে, তাই DB-level JOIN করা যায় না; data API বা event দিয়ে aggregate করতে হয়।
এই কারণেই microservice ব্যবহার করলে join strategy সম্পূর্ণ বদলে যায়।

🏁 Summary (এক লাইনে)

Monolith → DB JOIN
Microservice → API / Event JOIN

Q_8: Rate limiting এর জন্য কি কি ডাটা নিতে হয়? ইউজার স্পেসিফিকভাবে rate limit করবো কিভাবে?

Answer:
1️⃣ Rate Limiting বলতে কী বোঝায়?

Rate Limiting মানে হলো—
👉 নির্দিষ্ট সময়ের মধ্যে কতবার request করা যাবে তার সীমা নির্ধারণ করা।

উদাহরণ:

1 মিনিটে সর্বোচ্চ 60 request
1 ঘণ্টায় সর্বোচ্চ 1000 request

উদ্দেশ্য:

DDoS / brute-force attack ঠেকানো
Server overload রোধ করা
Fair usage নিশ্চিত করা

2️⃣ Rate Limiting করতে কী কী ডাটা লাগে?
🔑 Minimum Required Data

Rate limit করতে সাধারণত এই ডাটাগুলো লাগে:

🔍 Identifier হিসেবে কী ব্যবহার করা যায়?

IP Address
User ID
API Token
Email / Username
Device ID (advanced)

3️⃣ User-specific Rate Limiting কিভাবে করবো?
✅ Scenario–1: Logged-in User (Best & Accurate)

👉 User ID ব্যবহার করাই সবচেয়ে ভালো

Laravel Example:

RateLimiter::for('user-api', function (Request $request) {
    return Limit::perMinute(60)->by(
        optional($request->user())->id ?: $request->ip()
    );
});

✔ Login থাকলে → user_id
✔ Login না থাকলে → IP fallback

Route এ apply:

Route::middleware('throttle:user-api')
    ->get('/profile', fn () => 'ok');

✅ Scenario–2: API Token based (Mobile / Public API)

Limit::perMinute(100)->by($request->header('X-API-TOKEN'));

✔ Token-based control
✔ Scalable

✅ Scenario–3: IP-based (Guest User)

Limit::perMinute(30)->by($request->ip());

⚠️ NAT / shared IP হলে inaccurate হতে পারে

4️⃣ Rate Limit ডাটা কোথায় store হয়?

Laravel defaultভাবে ব্যবহার করে:

Cache system

👉 Production-এ Redis strongly recommended

5️⃣ Rate Limiting Algorithm (Simple View)

Laravel internally ব্যবহার করে:

Fixed Window / Sliding Window counter

Conceptually:

key = user_id + route
count++
if count > limit → block

6️⃣ Different Rate Limit per User Role (Advanced)

RateLimiter::for('api', function (Request $request) {
    if ($request->user()?->is_admin) {
        return Limit::none();
    }

    return Limit::perMinute(60)->by($request->user()->id);
});

✔ Admin unlimited
✔ Normal user limited

7️⃣ Response Headers (Client-side info)

Laravel auto পাঠায়:

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 12
Retry-After: 30

Client বুঝতে পারে কখন আবার request করবে

8️⃣ Interview-Ready Summary 🧠

Rate limiting requires an identifier (user ID / IP / token), a time window, request count, and a fast storage like Redis.
User-specific rate limiting is best implemented using authenticated user ID with cache-backed counters.

Git, GitHub, PR & Version Control Interview Questions in Bangla

Ruhul Amin Sujon — Wed, 28 Jan 2026 18:57:03 +0000

🔥 Git, GitHub, PR & Version Control – Interview Questions (Bangla)

🔸 Version Control Basics

প্রশ্ন ১: Version Control System (VCS) কী?

উত্তর:
Version Control System এমন একটি সিস্টেম যা কোডের প্রতিটি পরিবর্তনের ইতিহাস সংরক্ষণ করে এবং একাধিক ডেভেলপারকে একসাথে কাজ করতে সাহায্য করে।

প্রশ্ন ২: Version control কেন দরকার?

উত্তর:

কোড পরিবর্তনের ইতিহাস সংরক্ষণ
ভুল হলে আগের ভার্সনে ফিরে যাওয়া
একাধিক ডেভেলপার একসাথে কাজ করা
Conflict সহজে ম্যানেজ করা

প্রশ্ন ৩: Version control ছাড়া কী সমস্যা হয়?

উত্তর:

কোড overwrite হয়ে যেতে পারে
কে কী পরিবর্তন করেছে বোঝা যায় না
Backup বা rollback সম্ভব হয় না

প্রশ্ন ৪: Centralized ও Distributed VCS এর পার্থক্য কী?

উত্তর:

Centralized: SVN
Distributed: Git
Git এ সম্পূর্ণ repository লোকাল মেশিনে থাকে

প্রশ্ন ৫: Git কী?

উত্তর:
Git হলো একটি Distributed Version Control System যা Linus Torvalds তৈরি করেছেন।

প্রশ্ন ৬: Git আর GitHub কি এক জিনিস?

উত্তর:
না।

Git → version control tool
GitHub → Git repository hosting platform

প্রশ্ন ৭: GitHub ছাড়া কি Git ব্যবহার করা যায়?

উত্তর:
হ্যাঁ, সম্পূর্ণ লোকালভাবেও Git ব্যবহার করা যায়।

প্রশ্ন ৮: Repository কী?

উত্তর:
Repository হলো একটি প্রজেক্টের সম্পূর্ণ source code ও commit history সংরক্ষণের জায়গা।

প্রশ্ন ৯: Local ও Remote repository কী?

উত্তর:

Local → নিজের কম্পিউটারে
Remote → GitHub / GitLab এ

প্রশ্ন ১০: Git workflow কী?

উত্তর:
কোড লেখা → commit → push → pull request → review → merge

🔸 Basic Git Commands

প্রশ্ন ১১: git init কী করে?

উত্তর:
নতুন Git repository তৈরি করে।

প্রশ্ন ১২: git clone কী?

উত্তর:
Remote repository লোকাল মেশিনে কপি করে।

প্রশ্ন ১৩: git status কী দেখায়?

উত্তর:
Working directory ও staging area এর অবস্থা দেখায়।

প্রশ্ন ১৪: git add কী?

উত্তর:
ফাইল staging area-তে পাঠায়।

প্রশ্ন ১৫: git commit কী?

উত্তর:
Staged পরিবর্তন স্থায়ীভাবে history-তে সংরক্ষণ করে।

প্রশ্ন ১৬: ভালো commit message কেমন হওয়া উচিত?

উত্তর:

ছোট
পরিষ্কার
অর্থবোধক

উদাহরণ:

fix: login validation issue

প্রশ্ন ১৭: git log কী?

উত্তর:
সব commit history দেখায়।

প্রশ্ন ১৮: git diff কী?

উত্তর:
বর্তমান পরিবর্তন ও আগের commit এর পার্থক্য দেখায়।

প্রশ্ন ১৯: git reset কী?

উত্তর:
Commit বা staging বাতিল করতে ব্যবহৃত হয়।

প্রশ্ন ২০: git revert কী?

উত্তর:
নতুন commit তৈরি করে আগের commit undo করে।

🔸 Branch & Merge

প্রশ্ন ২১: Branch কী?

উত্তর:
Branch হলো মূল কোড থেকে আলাদা একটি development line।

প্রশ্ন ২২: Branch কেন দরকার?

উত্তর:

Feature আলাদা করে কাজ করা
Main branch নিরাপদ রাখা

প্রশ্ন ২৩: Default branch কোনটি?

উত্তর:
বর্তমানে main।

প্রশ্ন ২৪: git checkout -b কী?

উত্তর:
নতুন branch তৈরি ও switch করে।

প্রশ্ন ২৫: Merge কী?

উত্তর:
এক branch-এর কোড অন্য branch-এ যুক্ত করা।

প্রশ্ন ২৬: Merge conflict কী?

উত্তর:
একই লাইনে একাধিক পরিবর্তন হলে conflict হয়।

প্রশ্ন ২৭: Conflict কীভাবে resolve করা হয়?

উত্তর:

ম্যানুয়ালি কোড ঠিক করা
পুনরায় commit করা

প্রশ্ন ২৮: Fast-forward merge কী?

উত্তর:
যখন main branch এ নতুন commit না থাকে।

প্রশ্ন ২৯: Rebase কী?

উত্তর:
Commit history পরিষ্কার করার পদ্ধতি।

প্রশ্ন ৩০: Cherry-pick কী?

উত্তর:
নির্দিষ্ট একটি commit অন্য branch-এ নেওয়া।

🔸 GitHub & Pull Request

প্রশ্ন ৩১: Remote repository কী?

উত্তর:
GitHub বা GitLab এ থাকা repository।

প্রশ্ন ৩২: origin কী?

উত্তর:
Remote repository এর default নাম।

প্রশ্ন ৩৩: git push কী?

উত্তর:
Local commit remote এ পাঠায়।

প্রশ্ন ৩৪: git pull কী?

উত্তর:
Remote পরিবর্তন নিয়ে এসে merge করে।

প্রশ্ন ৩৫: git fetch ও git pull পার্থক্য কী?

উত্তর:

fetch → শুধু ডাটা আনে
pull → আনে + merge করে

প্রশ্ন ৩৬: Fork কী?

উত্তর:
অন্যের repository নিজের GitHub অ্যাকাউন্টে কপি করা।

প্রশ্ন ৩৭: Fork কেন দরকার?

উত্তর:
Open-source contribution এর জন্য।

প্রশ্ন ৩৮: Pull Request (PR) কী?

উত্তর:
এক branch-এর পরিবর্তন অন্য branch-এ যুক্ত করার অনুরোধ।

প্রশ্ন ৩৯: PR কেন দরকার?

উত্তর:

Code review
Bug ধরা
Team approval

প্রশ্ন ৪০: PR workflow কী?

উত্তর:

feature → push → PR → review → merge

প্রশ্ন ৪১: Code review কী?

উত্তর:
অন্য ডেভেলপার দ্বারা কোড যাচাই।

প্রশ্ন ৪২: PR merge এর ধরন কয়টি?

উত্তর:

Merge commit
Squash merge
Rebase merge

প্রশ্ন ৪৩: Squash merge কী?

উত্তর:
একাধিক commit একটিতে পরিণত করা।

প্রশ্ন ৪৪: Draft PR কী?

উত্তর:
কাজ চলমান অবস্থায় তৈরি করা PR।

🔸 Laravel + Git

প্রশ্ন ৪৫: .gitignore কী?

উত্তর:
যেসব ফাইল Git track করবে না সেগুলোর তালিকা।

প্রশ্ন ৪৬: Laravel এ কোন ফাইল gitignore করা হয়?

উত্তর:

.env
/vendor
/node_modules
/storage/*.log

প্রশ্ন ৪৭: .env ফাইল Git এ রাখা হয় না কেন?

উত্তর:
এতে database password ও secret key থাকে।

প্রশ্ন ৪৮: Git stash কী?

উত্তর:
অসম্পূর্ণ কাজ সাময়িকভাবে লুকিয়ে রাখা।

প্রশ্ন ৪৯: git stash pop কী?

উত্তর:
Stash করা কাজ ফিরিয়ে আনে।

প্রশ্ন ৫০: Git tag কী?

উত্তর:
Release version চিহ্নিত করতে ব্যবহৃত হয়।

প্রশ্ন ৫১: Semantic versioning কী?

উত্তর:
MAJOR.MINOR.PATCH

প্রশ্ন ৫২: Git hooks কী?

উত্তর:
Commit বা push এর আগে অটোমেটিক script চালানো।

প্রশ্ন ৫৩: Hotfix branch কী?

উত্তর:
Production bug দ্রুত ঠিক করার branch।

প্রশ্ন ৫৪: Feature branch কী?

উত্তর:
নতুন feature ডেভেলপ করার জন্য branch।

প্রশ্ন ৫৫: Professional Git workflow কেমন হওয়া উচিত?

উত্তর:

main → production
develop → testing
feature/* → new feature
hotfix/* → urgent bug

AS API Code Example

Ruhul Amin Sujon — Wed, 02 Jul 2025 11:35:23 +0000

Controller:

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Tv;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Validator;

class TvController extends Controller
{
    public function index()
    {
        try {
            $tvs = Tv::where('status', 1)->get();

            return response()->json([
                'status' => true,
                'statusCode' => 200,
                'message' => 'TV list retrieved successfully',
                'data' => $tvs
            ]);
        } catch (Exception $e) {

            // Log the error
            Log::error('Error in retrieving TV: ', [
                'message' => $e->getMessage(),
                'code' => $e->getCode(),
                'line' => $e->getLine(),
                'trace' => $e->getTraceAsString()
            ]);

            return response()->json([
                'status' => false,
                'statusCode' => 500,
                'message' => 'Something went wrong!!!',
                'data' => []
            ], 500);
        }
    }

    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|string',
            'channel_id' => 'required|string',
            'file' => 'required|file|image:jpg|image:png',
            'status' => 'nullable|in:0,1',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'status' => false,
                'statusCode' => 422,
                'message' => 'The given data was invalid',
                'data' => $validator->errors()
            ], 422);
        }

        try {
            // Handle file upload
            if ($request->hasFile('file')) {
                $filePath = $this->storeFile($request->file('file'));
                $img_url = $filePath ?? '';
            }

            $tv = Tv::create([
                'name' => $request->name,
                'channel_id' => $request->channel_id,
                'img_url' => $img_url,
                'status' => 1,
            ]);

            return response()->json([
                'status' => true,
                'statusCode' => 201,
                'message' => 'TV created successfully',
                'data' => $tv
            ], 201);
        } catch (Exception $e) {

            // Log the error
            Log::error('Error in storing TV: ', [
                'message' => $e->getMessage(),
                'code' => $e->getCode(),
                'line' => $e->getLine(),
                'trace' => $e->getTraceAsString()
            ]);

            return response()->json([
                'status' => false,
                'statusCode' => 500,
                'message' => 'Something went wrong!!!',
                'data' => []
            ], 500);
        }
    }
    public function show($id)
    {
        //
    }
    public function update(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'id' => 'required|exists:tvs,id',
            'name' => 'nullable|string',
            'channel_id' => 'nullable|string',
            'file' => 'nullable|file|image:jpg|image:png|image:jpeg',
            'status' => 'nullable|in:0,1',
        ]);

        if ($validator->fails()) {
            return response()->json([
                'status' => false,
                'statusCode' => 422,
                'message' => 'The given data was invalid',
                'data' => $validator->errors()
            ], 422);
        }

        try {
            $tv = Tv::findOrFail($request->id);

            $requestData = $request->except(['file', 'id']);
            $requestData['name'] = $requestData['name'] ?? $tv->name;
            $requestData['channel_id'] = $requestData['channel_id'] ?? $tv->title;
            $requestData['status'] = $requestData['status'] ?? $tv->singer_name;
            $requestData['img_url'] = $tv->img_url;
            $requestData['updated_at'] = now();

            // Handle file upload
            if ($request->hasFile('file')) {
                $filePath = $this->updateFile($request->file('file'), $tv);
                $requestData['img_url'] = $filePath ?? '';
            }

            $tv->update($requestData);

            return response()->json([
                'status' => true,
                'statusCode' => 200,
                'message' => 'TV updated successfully',
                'data' => $tv
            ]);
        } catch (Exception $e) {

            // Log the error
            Log::error('Error in updating TV: ', [
                'message' => $e->getMessage(),
                'code' => $e->getCode(),
                'line' => $e->getLine(),
                'trace' => $e->getTraceAsString()
            ]);

            return response()->json([
                'status' => false,
                'statusCode' => 500,
                'message' => 'Something went wrong!!!',
                'data' => []
            ], 500);
        }
    }
    public function destroy($id)
    {
        //
    }

    private function storeFile($file)
    {
        // Define the directory path
        $filePath = 'files/music/mp3';
        $directory = public_path($filePath);

        // Ensure the directory exists
        if (!file_exists($directory)) {
            mkdir($directory, 0777, true);
        }

        // Generate a unique file name
        $fileName = uniqid('music_', true) . '.' . $file->getClientOriginalExtension();

        // Move the file to the destination directory
        $file->move($directory, $fileName);

        // path & file name in the database
        # $path = $filePath . '/' . $fileName;
        $path = $fileName;
        return $path;
    }
    public function getMusic($filename)
    {
        try {
            $path = public_path('files/music/mp3/' . $filename);

            if (!file_exists($path)) {
                return $this->sendResponse(false, '404, File not found.', []);
            }

            return response()->file($path);
        } catch (Exception $e) {

            // Log the error
            Log::error('Error in get File: ', [
                'message' => $e->getMessage(),
                'code' => $e->getCode(),
                'line' => $e->getLine(),
                'trace' => $e->getTraceAsString()
            ]);

            return $this->sendResponse(false, 'Something went wrong!!!', [], 500);
        }
    }
    private function updateFile($file, $data)
    {
        // Define the directory path
        $filePath = 'files/music/mp3';
        $directory = public_path($filePath);

        // Ensure the directory exists
        if (!file_exists($directory)) {
            mkdir($directory, 0777, true);
        }

        // Generate a unique file name
        $fileName = uniqid('music_', true) . '.' . $file->getClientOriginalExtension();

        // Delete the old file if it exists
        $this->deleteOldFile($data);

        // Move the new file to the destination directory
        $file->move($directory, $fileName);

        // Store path & file name in the database
        # $path = $filePath . '/' . $fileName;
        $path = $fileName;
        return $path;
    }
    private function deleteOldFile($data)
    {
        if (!empty($data->img_url)) {
            $filePath = 'files/music/mp3';
            $directory = $data->img_url;
            $path = $filePath . '/' . $directory;

            $oldFilePath = public_path($path); // Use without prepending $filePath
            if (file_exists($oldFilePath)) {
                unlink($oldFilePath); // Delete the old file
                return true;
            } else {
                Log::warning('Old file not found for deletion', ['path' => $oldFilePath]);
                return false;
            }
        }
    }
}

আপনি নিচের মতো একটি Laravel রুট তৈরি করে /clear-cache এ গিয়ে cache, config, route এবং view clear করতে পারেন

use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Route;

Route::get('/clear-cache', function () {
    Artisan::call('cache:clear');
    Artisan::call('config:clear');
    Artisan::call('route:clear');
    Artisan::call('view:clear');

    return 'All caches (config, route, view, application) have been cleared!';
});

Previous one file store with get full path

    private function storeFile($file)
    {
        // Define the directory path
        // TODO: Change path if needed
        $filePath = 'files/images/country'; # change path if needed
        $directory = public_path($filePath);

        // Ensure the directory exists
        if (!file_exists($directory)) {
            mkdir($directory, 0777, true);
        }

        // Generate a unique file name
        // TODO: Change path if needed
        $fileName = uniqid('flag_', true) . '.' . $file->getClientOriginalExtension();

        // Move the file to the destination directory
        $file->move($directory, $fileName);

        // path & file name in the database
        $path = $filePath . '/' . $fileName;
        return $path;
    }
    private function updateFile($file, $data)
    {
        // Define the directory path
        // TODO: Change path if needed
        $filePath = 'files/images/country'; # change path if needed
        $directory = public_path($filePath);

        // Ensure the directory exists
        if (!file_exists($directory)) {
            mkdir($directory, 0777, true);
        }

        // Generate a unique file name
        // TODO: Change path following storeFile function
        $fileName = uniqid('flag_', true) . '.' . $file->getClientOriginalExtension();

        // Delete the old file if it exists
        $this->deleteOldFile($data);

        // Move the new file to the destination directory
        $file->move($directory, $fileName);

        // Store path & file name in the database
        $path = $filePath . '/' . $fileName;
        return $path;
    }
    private function deleteOldFile($data)
    {
        // TODO: ensure from database
        if (!empty($data->flag)) { # ensure from database
            $oldFilePath = public_path($data->flag); // Use without prepending $filePath
            if (file_exists($oldFilePath)) {
                unlink($oldFilePath); // Delete the old file
                return true;
            } else {
                Log::warning('Old file not found for deletion', ['path' => $oldFilePath]);
                return false;
              }
          }
      }

Repository:

<?php

namespace App\Modules\Products\Repositories;

use App\Modules\Products\Models\Product;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Exception;

class ProductRepository
{
    public function all()
    {
        $data = Product::latest()->get();

        return $data;
    }
    public function store(array $data, $userId)
    {
        DB::beginTransaction();
        try {
            $data['created_by'] = $userId;
            $data['updated_by'] = null;

            // Correct way to check file
            if (isset($data['photo']) && $data['photo'] instanceof UploadedFile && $data['photo']->isValid()) {
                $filePath = $this->storeFile($data['photo'], 'products', 'product_');
                $data['photo'] = $filePath;
            } else {
                $data['photo'] = null;
            }

            // Create the record in the database
            $created = Product::create($data);

            DB::commit();

            return $created->load('category', 'taxRate');
        } catch (Exception $e) {
            DB::rollBack();

            // Log the error
            Log::error('Error in storing data: ' , [
                'message' => $e->getMessage(),
                'code' => $e->getCode(),
                'line' => $e->getLine(),
                'trace' => $e->getTraceAsString()
            ]);

            return null;
        }
    }
    public function update(Product $product, array $data, $userId)
    {
        DB::beginTransaction();
        try {
            $data['updated_by'] = $userId;

            // Correct way to check file
            if (isset($data['photo']) && $data['photo'] instanceof UploadedFile && $data['photo']->isValid()) {
                $filePath = $this->updateFile($data['photo'], 'products', 'product_', $product->photo);
                $data['photo'] = $filePath;
            }

            // Perform the update
            $product->update($data);

            DB::commit();
            return $product;
        } catch (Exception $e) {
            DB::rollBack();

            // Log the error
            Log::error('Error updating data: ' , [
                'message' => $e->getMessage(),
                'code' => $e->getCode(),
                'line' => $e->getLine(),
                'trace' => $e->getTraceAsString()
            ]);

            return null;
        }
    }
    // In FloorRepository.php
    public function delete(Product $product)
    {
        DB::beginTransaction();
        try {
            // 1. Delete associated files
            if (!empty($product->photo)) {
                $this->deleteOldFile($product->photo);
            }
            // 5. Finally, delete the data itself
            $product->delete();

            DB::commit();
            return true;

        } catch (Exception $e) {
            DB::rollBack();

            Log::error('Error deleting data: ' , [
                'id' => $product->id,
                'message' => $e->getMessage(),
                'code' => $e->getCode(),
                'line' => $e->getLine(),
                'trace' => $e->getTraceAsString()
            ]);

            return false;
        }
    }
    public function find($id)
    {
        return Product::with('category', 'taxRate')->find($id);
    }
    private function storeFile($file, $filePath, $prefix)
    {
        // Define the directory path
        // TODO: Change path if needed
        # $filePath = 'files/images/country'; # change path if needed
        $directory = public_path($filePath);

        // Ensure the directory exists
        if (!file_exists($directory)) {
            mkdir($directory, 0777, true);
        }

        // Generate a unique file name
        // TODO: Change path if needed
        # $fileName = uniqid('flag_', true) . '.' . $file->getClientOriginalExtension();
        $fileName = uniqid($prefix, true) . '.' . $file->getClientOriginalExtension();

        // Move the file to the destination directory
        $file->move($directory, $fileName);

        // path & file name in the database
        $path = $filePath . '/' . $fileName;
        return $path;
    }
    private function updateFile($file, $filePath, $prefix, $oldFilePath = null)
    {
        // Delete the old file if it exists
        $this->deleteOldFile($oldFilePath);

        // Store path & file name in the database
        $path = $this->storeFile($file, $filePath, $prefix);
        return $path;
    }
    private function deleteOldFile($oldFilePath)
    {
        // TODO: ensure from database
        if (!empty($oldFilePath)) { # ensure from database
            $oldFullFilePath = public_path($oldFilePath); // Use without prepending $filePath
            if (file_exists($oldFullFilePath)) {
                unlink($oldFullFilePath); // Delete the old file
                return true;
            } else {
                Log::warning('Old file not found for deletion', ['path' => $oldFullFilePath]);
                return false;
            }
        }
    }
}

For Migration & other Commands

1. model & migration:

php artisan make:model BranchContactInfo -m

php artisan make:model BranchContactInfo -mcr

The -m flag creates a new migration file.
The -c flag creates a controller.
The -r flag specifies that it should be a resource controller, which includes all the standard methods for a CRUD (Create, Read, Update, Delete) application.

2. controller:

php artisan make:controller Api/PostController --api

php artisan make:controller ProductController --resource

3. Migration:

php artisan make:migration create_fields_table

php artisan make:migration add_telegram_group_link_to_settings_table

php artisan make:migration add_columns_to_users_table --table=users

Schema::create('rooms', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id')->nullable();
            $table->unsignedBigInteger('hotel_id')->nullable();
            $table->unsignedBigInteger('floor_id')->nullable();

            $table->foreignId('user_id')->constrained('users')->onDelete('cascade');
            $table->foreignId('hotel_id')->constrained('hotels')->onDelete('cascade');
            $table->foreignId('created_by')->nullable()->constrained('users')->onDelete('cascade');
            $table->foreignId('updated_by')->nullable()->constrained('users')->onDelete('cascade');

            $table->string('room_no')->nullable();
            $table->enum('bed_type', ['Single', 'Double', 'Triple'])->default('Single')->nullable();
            $table->boolean('has_ac')->default(true)->nullable();
            $table->text('description')->nullable();
            $table->enum('status', ['Active', 'Inactive'])->default('Active')->nullable();
$table->index(['id', 'lat', 'long'], 'idx_lat_long');
$table->string('status', 50)->nullable()->after('check_out')->default('confirmed');
            $table->decimal('rent',10, 2)->nullable()->default(0)->after('check_out');
            $table->timestamps();
        });

ii. add_columns

public function up()
{
Schema::table('settings', function (Blueprint $table) {
$table->string('telegram_group_link')->nullable()->after('task_timing');

$table->foreignId('building_id')->nullable()->after('user_id')->constrained('buildings')->onDelete('cascade');

$table->foreignId('popular_place_id')->nullable()->constrained('popular_places')->onDelete('cascade')->after('package_id');

$table->dropForeign(['hotel_id']);
$table->dropColumn('hotel_id');

$table->dropForeign(['floor_id']);
$table->dropColumn('floor_id');

$table->dropForeign(['room_id']);
$table->dropColumn('room_id');

$table->enum('status', ['pending', 'confirmed', 'checked_in', 'checked_out', 'cancelled'])
                  ->default('pending')
                  ->nullable()
                  ->change();

$table->renameColumn('price', 'rent');
    });
}

public function down()
{
    Schema::table('settings', function (Blueprint $table) {
        $table->dropColumn('telegram_group_link');
    });
}

4. seeder:

php artisan make:seeder UserSeeder

php artisan db:seed

5. Request Code

public function rules()
    {
        $data = $this->route('invitation_code');
        $id = $data?->id ?? null;

        return InvitationCode::rules($id);
    }

2nd part

public function rules()
    {
        // Get the route name and apply null-safe operator
        $routeName = $this->route()?->getName();

        if ($routeName === 'events.update') {
            return Event::updateRules();
        }

        return Event::rules();
    }

Postman token save

let responseData = pm.response.json();

if (responseData.success && responseData.data.token) {
    // pm.globals.set("token", responseData.data.token); // set global token
    pm.collectionVariables.set("token", responseData.data.token);
    console.log("Token set in collection variable successfully.");
} else {
    console.error("Failed to set token. Check response structure or API call.");
}

6. Highly suitable and necessary commands when deploying a Laravel project to a live server like CPanel

1st run clear-cache on your site
php artisan config:clear && php artisan route:clear && php artisan view:clear && php artisan optimize
php artisan storage:link

composer install --no-dev -o
php artisan config:clear
php artisan route:clear
php artisan view:clear
php artisan cache:clear
php artisan config:cache
php artisan route:cache
php artisan storage:link
composer install --optimize-autoloader --no-dev
php artisan optimize
php artisan optimize:clear
php artisan config:cache && php artisan route:cache

🚨 Why Sanctum Token API Not Working on cPanel?
✅ 1. Your API URL is wrong (APP_URL mismatch)

লোকালে তুমি হয়তো এভাবে করেছো:

APP_URL=http://127.0.0.1:8000
SANCTUM_STATEFUL_DOMAINS=127.0.0.1
SESSION_DOMAIN=127.0.0.1

cPanel-এ গেলে এগুলো ভুল হয়ে যায়।

❌ Wrong configuration (common mistake on cPanel)

APP_URL=http://localhost
SANCTUM_STATEFUL_DOMAINS=localhost
SESSION_DOMAIN=localhost

এগুলো shared hosting server এ কাজ করে না।

✅** Correct cPanel settings**

তোমার লাইভ ডোমেইন যদি হয়:

example.com

তাহলে .env এ দিতে হবে:

APP_URL=https://example.com
SESSION_DOMAIN=.example.com
SANCTUM_STATEFUL_DOMAINS=example.com

যদি তুমি subdomain ব্যবহার করো:

api.example.com

তাহলে:

APP_URL=https://api.example.com
SESSION_DOMAIN=.example.com
SANCTUM_STATEFUL_DOMAINS=example.com

আপনি যদি লোকাল মেশিনে (localhost) রান করা অ্যাপ টানেল করে পাবলিক URL বানাতে চান, যাতে যেকেউ ইন্টারনেট থেকে দেখতে পারে — সবচেয়ে সহজ সমাধান হলো ngrok, Cloudflare Tunnel, বা localtunnel ব্যবহার করা। নিচে সহজভাবে দেখাচ্ছি 👇

🚀 অপশন 1: ngrok (সবচেয়ে জনপ্রিয়)
✅ ধাপ:

1️⃣ ডাউনলোড করুন: https://ngrok.com

2️⃣ সাইন আপ করে auth token নিন
3️⃣ টার্মিনালে:

ngrok config add-authtoken YOUR_TOKEN

4️⃣ ধরুন আপনার লোকাল সার্ভার চলছে http://localhost:3000

ngrok http 3000

👉 আউটপুটে পাবেন:

Forwarding  https://abcd-1234.ngrok-free.app -> http://localhost:3000

এই URL যেকেউ খুলতে পারবে 🌍

☁️ অপশন 2: Cloudflare Tunnel (cloudflared) — ফ্রি ও স্টেবল
✅ ধাপ:

1️⃣ ডাউনলোড: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/

2️⃣ রান করুন:

cloudflared tunnel --url http://localhost:3000

👉 পাবেন এমন URL:

https://random-name.trycloudflare.com

🔧 অপশন 3: localtunnel (npm)

npm install -g localtunnel
lt --port 3000

👉 URL:

https://abc.loca.lt

🧪 Example

আপনার Node.js app যদি:

npm run dev
# running on http://localhost:4000

তাহলে:

ngrok http 4000

তারপর পাওয়া URL শেয়ার করুন ✅

𝐏𝐫𝐨𝐒𝐨𝐟𝐭 𝐄𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞: 𝟑-𝟓 𝐘𝐞𝐚𝐫. Laravel IQ - Part-02

Ruhul Amin Sujon — Mon, 26 May 2025 19:00:16 +0000

🧠 Laravel Developer, কিন্তু এগুলো জানেন না? শিখে নিন ৮টি Core বিষয় !

❓ আপনি কি নিচের Laravel বিষয়গুলো জানেন না?

Route Model Binding
Polymorphic Relationship
Middleware Priority
Eager Loading vs Lazy Loading
n+1 Query Problem
with() vs load() method-এর পার্থক্য
Pagination
Job & Queue System

✅ যদি Laravel এ কাজ করেন, তাহলে এগুলো জানা আপনার জন্য বাধ্যতামূলক। না জানলে বড় প্রজেক্টে আপনি বারবার performance, maintainability আর bug নিয়ে ঝামেলায় পড়বেন।

চলুন একে একে সবগুলো সহজ ভাষায় ও উদাহরণসহ বুঝে নেই।

🔹 প্রশ্ন ১. Route Model Binding – ID দিয়ে আর ঝামেলা না!

🔍 URL এর মধ্যে ID দিলে Laravel নিজে থেকেই Model খুঁজে এনে দিবে

✅ উদাহরণ:

Route::get('/users/{user}', function (User $user) {
    return $user->name;
});

Laravel নিজে User::findOrFail($id) চালিয়ে $user নামের ভ্যারিয়েবল তৈরি করে দিবে। {user} একটি id দিলে Laravel নিজেই User মডেল থেকে সেই id-এর row খুঁজে $user-এ inject করবে।

🛠️ সুবিধা:

কোড ছোট হয়
Route parameter-এর মাধ্যমে সরাসরি Eloquent model instance
অটো 404 পাওয়া যায়
IDE অটো suggest করে

➤ Custom Binding করা যায়?

হ্যাঁ, যদি আপনি ID ছাড়া অন্য কোনো field দিয়ে binding করতে চান যেমন username, তাহলে RouteServiceProvider এ আপনি define করতে পারেন:

public function boot()
{
    Route::bind('user', function ($value) {
        return \App\Models\User::where('username', $value)->firstOrFail();
    });
}

🔹 প্রশ্ন ২. Polymorphic Relationship: এক কমেন্ট দিয়ে সব কভার!

🔄 একই Comment model দিয়ে Post, Video, Image – সবকিছুতে কমেন্ট করা যাবে

➤ কী এটা?

Polymorphic Relationship হল এমন একটি রিলেশনশিপ যেখানে একটি model একাধিক model-এর সাথে একই রিলেশনশিপ ফর্ম ব্যবহার করে সংযুক্ত হতে পারে।

🔸 সমস্যা:

আপনি এমন একটি ওয়েব অ্যাপ বানাচ্ছেন যেখানে:

ব্যবহারকারীরা পোস্টে কমেন্ট করতে পারবে
আবার ভিডিওতেও কমেন্ট করতে পারবে

এখন আপনি কি আলাদা post_comments, video_comments টেবিল করবেন?

না, Laravel বলে—একটাই comments টেবিল বানান, আমরা বুঝে নেব কোনটা কার কমেন্ট।

🔸 Laravel Polymorphic Relationship দিয়ে এমন হবে:

🧾 Database Structure:

comments টেবিলে থাকবে:

id
body
commentable_id ➜ কোন জিনিসের ID
commentable_type ➜ কোন model (Post, Video)

🔸 Model Setup:

✅ Comment Model:

class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

✅ Post Model:

class Post extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

✅ Video Model:

class Video extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

🔸 কিভাবে ব্যবহার করবেন?

১. Post-এ কমেন্ট:

$post = Post::find(1);
$post->comments()->create([
    'body' => 'এই পোস্টটা দারুন ছিলো!',
]);

২. Video-তে কমেন্ট:

$video = Video::find(1);
$video->comments()->create([
    'body' => 'ভিডিওটা অসাধারণ!',
]);

৩. কোন Comment কার সেটা বের করা:

$comment = Comment::find(1);
$owner = $comment->commentable; // Post or Video

🔹 প্রশ্ন ৩. Middleware Priority – কার আগে কে চলবে?

Laravel-এ সব middleware একসাথে চললে কোনোটা আগে চলবে আর কোনটা পরে?

✅ উদাহরণ:

আপনি একটা middleware বানিয়েছেন যা language set করে, আরেকটা middleware আছে যা auth চেক করে।

Laravel এ middleware চালানোর অর্ডার যদি ঠিক না থাকে, তাহলে authenticated user এর ভাষা ঠিকভাবে সেট না-ও হতে পারে।

✅ Priority ঠিক করার জায়গা:

app/Http/Kernel.php ফাইলে নিচে protected $middlewarePriority অংশে সেট করতে হবে:

protected $middlewarePriority = [
    \App\Http\Middleware\SetLocale::class,
    \App\Http\Middleware\Authenticate::class,
];

🔹 ৪. Eager Loading vs Lazy Loading

📌 ধরুন আপনার Post আছে, আর তার সাথে Comments আছে।

Lazy Loading (Bad for performance if many):

$posts = Post::all();
foreach ($posts as $post) {
    echo $post->comments->count(); // এখানে প্রতি লুপে একবার query চালায়
}

Eager Loading (Good Practice):

$posts = Post::with('comments')->get();
foreach ($posts as $post) {
    echo $post->comments->count(); // শুধু ২টা query চালাবে
}

✅ পার্থক্য:

Lazy Loading = প্রয়োজন অনুযায়ী লোড হয় (তবে বেশি Query চালায়)
Eager Loading = আগেই সব রিলেশন নিয়ে আসে

ধরুন আপনি একটি admin panel বানাচ্ছেন, যেখানে ৫০টি order লিস্টে দেখাতে হবে এবং সাথে প্রতিটির customer এবং তার profile লোড করতে হবে।

আপনি যদি Lazy Loading করেন, তাহলে ১টা orders + ৫০টা customers + ৫০টা profiles = ১০১টি Query!
যদি Eager Loading করেন: Order::with(['customer.profile'])->get(); → ৩টি Query! ✔️

এটাই পার্থক্য — বুঝে না করলে performance মার খায়।

🔹 প্রশ্ন ৫. n+1 Query Problem – অজান্তেই আপনার App ধীরে হয়!

🤕 সমস্যা কী?

$users = User::all();
foreach ($users as $user) {
    echo $user->profile->phone;
}

এখানে ধরুন ১০০ জন ইউজার আছে। তাহলে হবে:

১টি query: users টেবিল থেকে
১০০টি query: প্রতিটি profile এর জন্য

= মোট ১০১টি query! ভয়ংকর!

✅ সমাধান:

$users = User::with('profile')->get();

এখন ২টি query চলবে: ১টা users, ১টা profiles। Performance ৫০x ভালো!

🔹প্রশ্ন ৬. with() vs load() – অনেকেই গুলিয়ে ফেলে

✅ with():

Query এর সময়েই রিলেশন নিয়ে আসে। Query builder এর সাথে চলে।

$posts = Post::with('comments')->get();

✅ load():

Model পাওয়ার পর আলাদাভাবে রিলেশন লোড করে। Model instance এর সাথে চলে।

$post = Post::find(1);
$post->load('comments');

🚦 কখন কোনটা?

with() – যখন একসাথে query করতে চান
load() – যখন model আগে থেকেই আছে, পরে রিলেশন দরকার

🔹প্রশ্ন ৭. Pagination না জানলে কী হয়?

✅ Laravel-এ Pagination ব্যবহার না করলে আপনি হয়তো একবারেই ৫০০টা বা ৫০০০টা ডাটা get() দিয়ে নিয়ে নিচ্ছেন! এতে হয়ে যাচ্ছে বিশাল একটি ভুল – কারণ এত ডাটা একসাথে RAM-এ উঠানো মানে হচ্ছে: সার্ভার স্লো, রেসপন্স টাইম বেশি, এবং অ্যাপ ধীর গতির।

উদাহরণ:

$users = User::all(); // ❌ – সব user একবারে টেনে আনছে

এই কোড যদি admin panel-এর কোনো টেবিলে ব্যবহার করেন, তাহলে শুরুতেই ১০,০০০ জন ব্যবহারকারীর সব ডাটা টেনে আনছে – যেটা একদমই অপ্টিমাইজড না।

সমাধান:

$users = User::paginate(20); // ✅ প্রতিবার ২০টি করে ডাটা আসবে

এখন শুধু প্রথম ২০টি user আসবে, pagination link থাকবে (Next, Previous), UI-ও দ্রুত রেসপন্স করবে।

Laravel Pagination আপনাকে built-in pagination link ({{ $users->links() }}) দিয়ে দেয়, যেখানে Bootstrap বা Tailwind UI নিজে থেকেই render হয়।

⚠️ Pagination না বুঝলে কী সমস্যা হতে পারে?

বড় ডাটাসেট লোড করলে memory overflow হয়ে যায়
User interface হ্যাং করে
Lazy loading বা infinite scroll করা যায় না
Mobile user-দের জন্য page load time বেড়ে যায়

✅ প্রফেশনাল Laravel ডেভেলপার হলে Pagination মাস্ট!

সব লিস্টে paginate() বা simplePaginate() ব্যবহার করুন
API বানালে meta, links সহ JSON ফর্ম্যাটে paginate করুন
Blade টেমপ্লেটে {{ $items->links() }} ব্যবহার করতে ভুলবেন না

🔹প্রশ্ন ৮. Job & Queue System না জানলে কী হয়?

✅ Laravel-এ যদি আপনি সব কাজ রিয়েল-টাইমে controller-এর ভেতর করে ফেলেন — যেমন, ইমেইল পাঠানো, ফাইল প্রসেসিং, API থেকে বড় রেসপন্স আনানো — তাহলে ইউজারকে অপেক্ষা করতে হয়। এতে অ্যাপ ধীর হয়ে যায়, ইউজার বিরক্ত হয়।

Laravel আপনাকে Job & Queue-এর মাধ্যমে ব্যাকগ্রাউন্ডে সেই কাজগুলো চালানোর সুযোগ দেয়।

🔧 উদাহরণ

ধরুন, কেউ আপনার অ্যাপে রেজিস্ট্রেশন করলো। তখন আপনি চাইছেন তাকে একটি Welcome Email পাঠাতে।

Wrong Way: (সব একসাথে):

public function register(Request $request)
{
    // User create...
    Mail::to($user->email)->send(new WelcomeMail($user)); // ❌ এই লাইনে ইউজারকে অপেক্ষা করতে হয়
}

Good Way: (Queue ব্যবহার):

php artisan make:job SendWelcomeEmailJob

🧠 SendWelcomeEmailJob.php

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use App\Mail\WelcomeMail;
use Illuminate\Support\Facades\Mail;

class SendWelcomeEmailJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $user;

    public function __construct($user)
    {
        $this->user = $user;
    }

    public function handle(): void
    {
        Mail::to($this->user->email)->send(new WelcomeMail($this->user));
    }
}

Controller-এ Job Dispatch করা

public function register(Request $request)
{
    $user = User::create([
        'name' => $request->name,
        'email' => $request->email,
        'password' => bcrypt($request->password),
    ]);

    // ✅ ইমেইল পাঠানো ব্যাকগ্রাউন্ডে চলে যাবে:
    dispatch(new SendWelcomeEmailJob($user));

    return response()->json(['message' => 'Registration successful']);
}

Queue সেটআপ (ডেভ এলভেল — database)

php artisan queue:table
php artisan migrate

.env ফাইলে নিচের লাইনটি যুক্ত/পরিবর্তন করুন:
QUEUE_CONNECTION=database

তারপর Queue Worker চালান:
php artisan queue:work

✅ এখন কী হলো?

ইউজার রেজিস্ট্রেশন করলো
response পেল ১ সেকেন্ডের মধ্যে
Welcome Email meanwhile ব্যাকগ্রাউন্ডে গিয়েই চলে গেল, সে বুঝলোও না!

⚠️ Job & Queue System না জানলে যা হতে পারে:

ইউজার Action করলে response পেতে সময় বেশি লাগে
Server Load বেড়ে যায়
ইমেইল, SMS বা বড় প্রসেসিং এ কাজ স্লো হয়ে যায়
Real-time Notification দেওয়া সম্ভব হয় না
আগে যদি আপনি Mail::send() সরাসরি ব্যবহার করতেন, তাহলে পুরো Email Sending ব্লক করে রাখতো ইউজারকে।
এখন Job + Queue দিয়ে সব async হয়ে গেছে — সার্ভারেও চাপ কম, ইউজারও খুশি।

🧠 উপসংহার

Laravel দিয়ে শুধুমাত্র কাজ চালিয়ে নেওয়া আর প্রোডাকশন লেভেল অ্যাপ তৈরি করার মধ্যে অনেক তফাৎ।

যে বিষয়গুলো না জানলে আপনি প্রায় নিশ্চিতভাবেই সমস্যায় পড়বেন:

Route Model Binding না জানলে প্রতি রাউটে boilerplate কোড লিখতে হয়
Polymorphic Relationship না জানলে বারবার structure ডুপ্লিকেট হয়
Middleware Priority না বুঝলে request flow unpredictable হয়ে পড়ে
Eager vs Lazy Loading না জানলে ব্যাকেন্ড ধীরগতির হয়
n+1 Problem থেকে Performance মার খায়
with() vs load() এর misuse করে Unnecessary Query চলে
Pagination ছাড়া বড় ডাটা লিস্ট করলে অ্যাপ হ্যাং করে
Job & Queue System না জানলে ইউজারকে বেশি সময় অপেক্ষা করাতে হয়

📢 শেষ কথা

Laravel শেখা মানেই শুধু Route, Controller, Model জানা নয়। আপনাকে জানতে হবে Performance, Scalability এবং Maintainability— যাতে ভবিষ্যতের অ্যাপ বড় হলেও আপনি একাই হ্যান্ডেল করতে পারেন।

𝐏𝐫𝐨𝐒𝐨𝐟𝐭 𝐄𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞: 𝟑-𝟓 𝐘𝐞𝐚𝐫. Laravel IQ - Part-01

Ruhul Amin Sujon — Mon, 26 May 2025 18:36:42 +0000

প্রশ্ন 1: GET এবং POST এর মধ্যে পার্থক্য কী?

উত্তর:

GET: ইউআরএল এর মাধ্যমে ডেটা পাঠায়, সাধারণত ডেটা পড়ার জন্য।
POST: body এর মাধ্যমে ডেটা পাঠায়, সাধারণত নতুন ডেটা তৈরি বা সাবমিট করার জন্য।

প্রশ্ন ২: আপনি কীভাবে Laravel-এ Route Model Binding ইমপ্লিমেন্ট করবেন? একটি উদাহরণ দিতে পারেন কি?

উত্তর:

Laravel-এ Route Model Binding এমন একটি ফিচার যা অটোমেটিকভাবে URI-তে দেওয়া ID বা slug অনুযায়ী সংশ্লিষ্ট মডেলের ইনস্ট্যান্স খুঁজে এনে কন্ট্রোলারে পাস করে দেয়। এতে করে আলাদা করে find() বা where() মেথড ব্যবহার করতে হয় না।

Laravel-এ দুই ধরনের Route Model Binding আছে:

Implicit Binding (স্বয়ংক্রিয়)
Explicit Binding (স্পষ্টভাবে)

✅ উদাহরণ: Implicit Route Model Binding

ধরা যাক, আমাদের একটি Post মডেল আছে।

🔸 Route:

use App\Models\Post;

Route::get('/posts/{post}', [PostController::class, 'show']);

এখানে {post} হল route parameter এবং Laravel বুঝে নিবে যে এটি App\Models\Post মডেল এর instance।

🔸 Controller:

public function show(Post $post)
{
    return view('posts.show', compact('post'));
}

এখানে $post অটোমেটিকভাবে ওই ID অনুযায়ী ডাটাবেজ থেকে খুঁজে আনা হবে। যদি ID মেলে না, তাহলে 404 error দেওয়া হবে।

✅ উদাহরণ: Explicit Route Model Binding

এটি তখন ব্যবহার করা হয় যখন আপনি default key (ID) ছাড়া অন্য কিছু দিয়ে খুঁজতে চান, যেমন slug।

🔸 RouteServiceProvider:

use App\Models\Post;
use Illuminate\Support\Facades\Route;

public function boot()
{
    Route::bind('post', function ($value) {
        return Post::where('slug', $value)->firstOrFail();
    });
}

🔸 Route:

Route::get('/posts/{post}', [PostController::class, 'show']);

🔸 Controller:

public function show(Post $post)
{
    return view('posts.show', compact('post'));
}

এখানে route এর {post} অংশটা দিয়ে slug অনুসারে post পাওয়া যাবে।

🔚 উপসংহার:

Route Model Binding Laravel-এ কোডকে পরিষ্কার ও ছোট রাখে এবং বেটার পারফর্মেন্স নিশ্চিত করে। Implicit binding সহজ এবং দ্রুত, আর explicit binding কাস্টম ফিল্ডের জন্য ব্যবহার হয়।

প্রশ্ন ৩: Laravel-এর Eloquent ORM-এ Eager Loading কী? এটি Lazy Loading থেকে কীভাবে আলাদা? N+1 সমস্যা কী, এটি কেন হয় এবং কিভাবে এটি সমাধান করবেন?

উত্তর:

✅ Eager Loading কী?

Eager Loading হল Eloquent ORM-এর একটি টেকনিক যা সম্পর্কিত মডেলের ডেটা আগেই (একসাথে) লোড করে আনে, যাতে অতিরিক্ত query না চলে।

🔸 সাধারণভাবে, আমরা with() মেথড ব্যবহার করে eager loading করি।

🟢 উদাহরণ:

$users = User::with('posts')->get();

এই ক্ষেত্রে, প্রতিটি User এর সাথে সম্পর্কিত Post গুলোও একসাথে একটি আলাদা query দিয়ে আগেই লোড হয়ে যাবে। এতে performance ভালো হয়।

✅ Lazy Loading কী?

Lazy Loading মানে হল, যখন মূল মডেল লোড হয় তখন শুধুমাত্র মূল ডেটা লোড হয়। কিন্তু যখন সম্পর্কিত ডেটা এক্সেস করা হয়, তখন আলাদা করে query চলে।

🔴 উদাহরণ:

$users = User::all();

foreach ($users as $user) {
    echo $user->posts; // প্রতিবার এখানে আলাদা query চলবে
}

এই ক্ষেত্রে, প্রথমে সব User লোড হচ্ছে, তারপর প্রতিটি User এর জন্য posts লোড করতে আলাদা আলাদা query চলবে। এটাকেই বলে N+1 problem।

❗ N+1 Problem কী?

N+1 Problem তখন হয়, যখন আপনি একটি মূল মডেল (যেমন User) লোড করেন এবং প্রতিটি instance এর জন্য সম্পর্কিত মডেল (যেমন Post) আলাদা করে লোড হয়।

🔸 উদাহরণ:

$users = User::all(); // 1 query
foreach ($users as $user) {
    $user->posts;     // প্রতিটি user এর জন্য 1 করে query = N query
}

মোট query = 1 (User) + N (Posts) = N+1

এই সমস্যা performance কমিয়ে দেয়।

✅ সমাধান: Eager Loading ব্যবহার করুন

$users = User::with('posts')->get(); // 2টি query-তেই কাজ শেষ

১টি query দিয়ে সব User আনা হয়।
২য় query দিয়ে সব posts আনা হয় যেগুলো ঐ সব user-এর।

🧠 Tips:

multiple relation eager load করতে পারেন:

Post::with(['user', 'comments'])->get();

nested relation eager load করতে পারেন:

User::with('posts.comments')->get();

🔚 সংক্ষেপে পার্থক্য:

প্রশ্ন 4: Laravel-এ Accessor এবং Mutator কী এবং এগুলো কীভাবে ব্যবহার করা হয়?

উত্তর:

Accessor: মডেল থেকে ডেটা পড়ার আগে ডেটা প্রসেস করে।
Mutator: মডেলে ডেটা সেভ করার আগে প্রসেস করে।

// Accessor
public function getFullNameAttribute()
{
    return $this->first_name . ' ' . $this->last_name;
}

// Mutator
public function setPasswordAttribute($value)
{
    $this->attributes['password'] = bcrypt($value);
}

প্রশ্ন 5: Laravel-এ Authentication এবং Authorization দুটি ভিন্ন কিন্তু সম্পর্কিত সিকিউরিটি কনসেপ্ট। নিচে বাংলা ভাষায় বিস্তারিত ব্যাখ্যা দেওয়া হলো:

উত্তর:

✅ Authentication (প্রমাণীকরণ)

Authentication মানে হচ্ছে ব্যবহারকারীর পরিচয় যাচাই করা — সে কে?

🔹 Laravel-এ Authentication কীভাবে কাজ করে:

ইউজার লগইন করে (ইমেইল/পাসওয়ার্ড দিয়ে)
Laravel Auth ফ্যাসেড ব্যবহার করে ব্যবহারকারীর পরিচয় নিশ্চিত করে
সফল হলে session বা token এর মাধ্যমে ইউজারকে লগইন অবস্থায় রাখে

🔧 উদাহরণ:

if (Auth::check()) {
    // ইউজার লগইন অবস্থায় আছে
}

🔐 Laravel Authentication Features:

Login, Register, Logout
Password reset
API Token authentication (Sanctum/Passport)
Laravel Breeze, Jetstream, Fortify (Authentication scaffolding)

✅ Authorization (অনুমোদন)

Authorization মানে হচ্ছে ব্যবহারকারী কি নির্দিষ্ট কাজ করার অনুমতি পাবে?

👉 পরিচয় নিশ্চিত হওয়ার পরে, Laravel দেখে ইউজার কোনো নির্দিষ্ট রিসোর্স অ্যাক্সেস করতে পারবে কি না।

🔹 Laravel-এ Authorization কীভাবে হয়:

Gate এবং Policy ব্যবহার করে
নির্দিষ্ট রোল বা পারমিশন যাচাই করা হয়

🔧 উদাহরণ:

if (Auth::user()->can('update', $post)) {
    // ইউজার এই পোস্ট আপডেট করতে পারবে
}

🔁 Authentication vs Authorization তুলনা:

✅ Laravel Example Scenario

// Authentication Middleware
Route::middleware('auth')->group(function () {

    // Authorization check
    Route::get('/post/{post}/edit', function (Post $post) {
        if (Gate::allows('edit-post', $post)) {
            // Edit form
        } else {
            abort(403);
        }
    });

});

🔚 উপসংহার

Authentication বলে ইউজার "কে"
Authorization বলে ইউজার "কি করতে পারে"

👉 Laravel-এ এই দুইটি পরিষ্কারভাবে আলাদা করা হয়েছে, এবং তাদের জন্য আলাদা মেকানিজম ব্যবহার হয়।

প্রশ্ন ৬: Laravel-এ আপনি কীভাবে একটি Custom Authentication Driver ইমপ্লিমেন্ট করবেন?

✅ উত্তর:

Laravel সাধারণত session এবং token (API) ভিত্তিক authentication সাপোর্ট করে, তবে আপনি চাইলে নিজের মতো করে একটি Custom Authentication Driver তৈরি করতে পারেন।

Laravel-এ custom authentication driver তৈরি করতে হলে নিচের ধাপগুলো অনুসরণ করতে হয়:

🛠️ ধাপ ১: Custom Guard Class তৈরি করুন

ধরুন আপনি একটি CustomAuthGuard নামের class বানাবেন।

🔸 app/Auth/CustomAuthGuard.php

namespace App\Auth;

use Illuminate\Contracts\Auth\Guard;
use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Http\Request;
use Illuminate\Contracts\Auth\Authenticatable;

class CustomAuthGuard implements Guard
{
    protected $request;
    protected $provider;
    protected $user;

    public function __construct(UserProvider $provider, Request $request)
    {
        $this->provider = $provider;
        $this->request = $request;
    }

    public function check()
    {
        return !is_null($this->user());
    }

    public function user()
    {
        if (!is_null($this->user)) {
            return $this->user;
        }

        $id = $this->request->session()->get('custom_user_id');

        if ($id) {
            $this->user = $this->provider->retrieveById($id);
        }

        return $this->user;
    }

    public function id()
    {
        return $this->user()?->getAuthIdentifier();
    }

    public function validate(array $credentials = [])
    {
        $user = $this->provider->retrieveByCredentials($credentials);

        if ($user && $this->provider->validateCredentials($user, $credentials)) {
            $this->user = $user;
            return true;
        }

        return false;
    }

    public function setUser(Authenticatable $user)
    {
        $this->user = $user;
        return $this;
    }
}

🛠️ ধাপ ২: Service Provider এর মাধ্যমে Register করুন

🔸 App\Providers\AuthServiceProvider.php

use App\Auth\CustomAuthGuard;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\ServiceProvider;

public function boot()
{
    Auth::extend('custom_guard', function ($app, $name, array $config) {
        $provider = Auth::createUserProvider($config['provider']);

        return new CustomAuthGuard($provider, $app['request']);
    });
}

🛠️ ধাপ ৩: config/auth.php ফাইলে Guard যুক্ত করুন

'guards' => [
    'custom' => [
        'driver' => 'custom_guard',
        'provider' => 'users',
    ],
],

🛠️ ধাপ ৪: কিভাবে ব্যবহার করবেন

if (Auth::guard('custom')->attempt(['email' => 'test@example.com', 'password' => 'secret'])) {
    // Login successful
}

🧠 সংক্ষেপে:
ধাপ কাজ
১ Custom Guard class তৈরি করুন
২ Auth::extend() এর মাধ্যমে register করুন
৩ config/auth.php-এ custom guard যুক্ত করুন
৪ Auth::guard('custom') দিয়ে ব্যবহার করুন

🔚 উপসংহার:

Custom authentication তখন দরকার হয় যখন আপনি Session/Token ছাড়াও ভিন্ন কোনো প্রক্রিয়ায় user কে authenticate করতে চান — যেমন API Key, Third-Party Token, LDAP ইত্যাদি।

প্রশ্ন ৭: Laravel-এ Queues কী এবং কেন ব্যবহার করা হয়? এমন একটি বাস্তব উদাহরণ দিন যেখানে আপনি Queue ব্যবহার করবেন।

✅ উত্তর:

✅ Queues কী?

Queue (কিউ) হলো Laravel-এর একটি ফিচার যা আপনাকে দীর্ঘ সময় লাগা কাজগুলোকে পেছনে (background) প্রক্রিয়াকরণ করতে সাহায্য করে, যেন ইউজার দ্রুত response পায়।

এগুলো jobs আকারে এক বা একাধিক worker দ্বারা প্রসেস হয়।

✅ কেন Queues ব্যবহার করা হয়?

Queues ব্যবহারের প্রধান কারণগুলো হলো:

✅ পারফরম্যান্স বৃদ্ধি: যেসব কাজ অনেক সময় নেয়, সেগুলো ব্যাকগ্রাউন্ডে পাঠিয়ে ফেলা যায়।
✅ User Experience উন্নয়ন: ইউজার request-এর সাথে সাথে response পায়, কাজটি পরে প্রসেস হয়।
✅ Resources বাঁচানো: Worker নির্দিষ্ট resource ব্যবহার করে কাজ সম্পাদন করে।

🧠 Queue ছাড়া vs Queue সহ

🔴 Queue ছাড়া:

public function sendEmail()
{
    Mail::to($user)->send(new WelcomeMail());
    return "Mail Sent!";
}

এখানে mail পাঠাতে অনেক সময় লাগতে পারে, যেটা user এর জন্য ধীর অনুভূতি তৈরি করে।

🟢 Queue সহ:

public function sendEmail()
{
    dispatch(new SendWelcomeMailJob($user));
    return "Mail Queued!";
}

এখানে কাজটি queue তে পাঠিয়ে দেওয়া হয়, আর ইউজার সাথে সাথে response পায়।

✅ বাস্তব উদাহরণ: Email Sending

ধরা যাক, আপনি একজন ইউজারকে রেজিস্ট্রেশনের পর Welcome Email পাঠাতে চান। Email পাঠাতে সময় লাগে — তাই এটি queue-তে পাঠানো উত্তম।

১. Job তৈরি করুন:

php artisan make:job SendWelcomeEmail

২. Job কোড:

public function handle()
{
    Mail::to($this->user->email)->send(new WelcomeMail($this->user));
}

৩. Dispatch করুন Controller থেকে:

dispatch(new SendWelcomeEmail($user));

✅ Queue চালু করতে:

.env ফাইলে:

QUEUE_CONNECTION=database

Queue table তৈরি:

php artisan queue:table
php artisan migrate

Queue worker চালু:

php artisan queue:work

✅ Queue-এ আরও যেসব কাজ পাঠানো যায়:

ইমেইল পাঠানো (Email Sending)
রিপোর্ট জেনারেট করা (PDF, Excel)
ভিডিও প্রসেসিং
নোটিফিকেশন পাঠানো
বিলম্বিত কাজ (Delayed Jobs)

🔚 সংক্ষেপে:

✅ প্রশ্ন ৮: Laravel-এ আপনি কীভাবে Job তৈরি ও Dispatch করবেন?

✅ উত্তর:

🔷 Job কী?

Job হলো একটি ক্লাস যা Laravel Queue-এর মাধ্যমে delay বা background-এ কাজ সম্পন্ন করতে ব্যবহৃত হয়। যেমন: ইমেইল পাঠানো, রিপোর্ট তৈরি, ভিডিও প্রসেস ইত্যাদি।

🛠️ Job তৈরি করার ধাপ:

✅ ধাপ ১: Job ক্লাস তৈরি করুন

php artisan make:job SendWelcomeEmail

এতে app/Jobs/SendWelcomeEmail.php ফাইলে একটি ক্লাস তৈরি হবে।

✅ ধাপ ২: Job-এ কাজ লিখুন

namespace App\Jobs;

use App\Mail\WelcomeMail;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Support\Facades\Mail;

class SendWelcomeEmail implements ShouldQueue
{
    use Queueable;

    protected $user;

    public function __construct($user)
    {
        $this->user = $user;
    }

    public function handle()
    {
        // মেইল পাঠানোর কাজ
        Mail::to($this->user->email)->send(new WelcomeMail($this->user));
    }
}

বি.দ্র.: ShouldQueue ইন্টারফেসটি Laravel কে বলে দেয় যে এটি queue-তে প্রসেস করতে হবে।

✅ ধাপ ৩: Job Dispatch করুন

ধরা যাক, ইউজার রেজিস্ট্রেশনের পরে এই Job টি Dispatch করবেন।

use App\Jobs\SendWelcomeEmail;

public function register(Request $request)
{
    $user = User::create([...]);

    // Dispatch Job
    dispatch(new SendWelcomeEmail($user));

    return response()->json(['message' => 'User registered and mail queued']);
}

🛠️ Queue চালু করার ধাপ (যদি queue ব্যবহার করেন):

১. .env ফাইলে সেট করুন:

QUEUE_CONNECTION=database

২. Queue table তৈরি করুন:

php artisan queue:table
php artisan migrate

৩. Worker চালু করুন:

php artisan queue:work

🧠 আরও কিছু তথ্য:

✅ আপনি Delay সহ Dispatch করতে পারেন:

dispatch(new SendWelcomeEmail($user))->delay(now()->addMinutes(5));

✅ চেইনিং করে একাধিক Job সিরিয়ালি চলাতে পারেন:

SendWelcomeEmail::withChain([
    new LogEmailSent($user),
    new NotifyAdmin($user),
])->dispatch();

🔚 সংক্ষেপে:

✅ প্রশ্ন ৯: Laravel-এ যেসব ধরনের Testing আছে, সেগুলো ব্যাখ্যা করুন এবং কখন কোনটি ব্যবহার করবেন তা উল্লেখ করুন।

✅ উত্তর:

🧪 Laravel-এ Testing এর ধরনসমূহ:

Laravel মূলত ৩ ধরণের টেস্টিং সাপোর্ট করে:

✅ Feature Testing
✅ Unit Testing
✅ Browser Testing (Dusk)

🔹 1. Unit Testing

🔸 এই টেস্ট ছোট ছোট ফাংশন বা ক্লাসকে isolate করে পরীক্ষা করে।
🔸 সাধারণত Model, Service class বা Helper function ইত্যাদিকে test করতে ব্যবহৃত হয়।

➤ কখন ব্যবহার করবেন:

যখন আপনি চান একটি নির্দিষ্ট মেথড সঠিকভাবে কাজ করছে কিনা তা যাচাই করতে।

➤ উদাহরণ:

php artisan make:test MathHelperTest --unit

public function test_add_numbers_correctly()
{
    $this->assertEquals(4, MathHelper::add(2, 2));
}

🔹 2. Feature Testing

🔸 এটি পুরোপুরি একটি feature (যেমনঃ route, controller, middleware) পরীক্ষা করে।
🔸 এখানে HTTP request simulate করে সম্পূর্ণ ফ্লো টেস্ট করা হয়।

➤ কখন ব্যবহার করবেন:

যখন আপনি চেক করতে চান, একটি ফিচার ঠিকভাবে কাজ করছে কিনা — যেমন ফর্ম সাবমিশন, লগইন, ইউজার রেজিস্ট্রেশন ইত্যাদি।

➤ উদাহরণ:

php artisan make:test UserRegistrationTest

public function test_user_can_register()
{
    $response = $this->post('/register', [
        'name' => 'Ruhul',
        'email' => 'ruhul@example.com',
        'password' => 'secret',
        'password_confirmation' => 'secret',
    ]);

    $response->assertRedirect('/home');
    $this->assertDatabaseHas('users', ['email' => 'ruhul@example.com']);
}

🔹 3. Browser Testing (Laravel Dusk)

🔸 এটি একটি End-to-End (E2E) টেস্টিং সিস্টেম যা আসল browser ব্যবহার করে UI টেস্ট করে।
🔸 এই টেস্ট ইউজার ইন্টারফেসে ক্লিক, টাইপ, রিডাইরেক্ট ইত্যাদি অনুকরণ করে।

➤ কখন ব্যবহার করবেন:

ফর্ম, UI ইন্টারঅ্যাকশন বা জাভাস্ক্রিপ্ট টেস্ট করতে চাইলে।
লগইন/রেজিস্ট্রেশন প্রক্রিয়ার ভিজ্যুয়াল ফ্লো দেখতে চাইলে।

➤ উদাহরণ:

php artisan dusk:make LoginTest

public function test_login()
{
    $this->browse(function ($browser) {
        $browser->visit('/login')
                ->type('email', 'test@example.com')
                ->type('password', 'password')
                ->press('Login')
                ->assertPathIs('/home');
    });
}

🧠 সংক্ষেপে পার্থক্য:

✅ Laravel-এ Test চালানোর কমান্ড:

php artisan test

নির্দিষ্ট test file চালাতে:

php artisan test --filter=UserRegistrationTest

🔚 উপসংহার:

Laravel-এ testing সিস্টেম অনেক শক্তিশালী এবং development-এর সময় প্রতিটি ধরণের test সঠিকভাবে ব্যবহার করলে bug-free ও বিশ্বাসযোগ্য অ্যাপ তৈরি করা যায়।

✅ প্রশ্ন ১০: Laravel টেস্টে আপনি কীভাবে dependency mock করবেন? একটি উদাহরণ দিন।

✅ উত্তর:

🧠 Mocking মানে কী?

Mocking মানে হলো এমন কোনো class বা object-এর নকল (fake) ভার্সন তৈরি করা, যাতে আমরা আসল dependency-এর behavior পরিবর্তন করে test করতে পারি।

Laravel এ mocking সাধারণত service, external API, repository, notification, mail ইত্যাদি ক্ষেত্রে করা হয়।

🔧 Mocking Dependency কবে দরকার হয়?

যখন আপনি কোনো external service (যেমন: payment gateway, SMS API) ব্যবহার করছেন।
যখন আপনি এমন কোনো ক্লাস বা সার্ভিস টেস্ট করছেন, যেটি অন্য ক্লাসের উপর নির্ভর করে।
যাতে আপনার টেস্টে "side effects" না হয় (যেমন আসল API call, database change ইত্যাদি)।

✅ উদাহরণ: একটি Service Class কে Mock করা

ধরা যাক, আপনি একটি PaymentService ব্যবহার করছেন যেটা আসল API call করে।

🔹 Step 1: আসল সার্ভিস ক্লাস (Mock করার জন্য)

namespace App\Services;

class PaymentService
{
    public function charge($amount)
    {
        // আসল API call (যেটা আমরা টেস্টে করতে চাই না)
        return "Charged {$amount} taka!";
    }
}

🔹 Step 2: Controller যেটি এই সার্ভিস ব্যবহার করে

namespace App\Http\Controllers;

use App\Services\PaymentService;

class PaymentController extends Controller
{
    public function pay(PaymentService $payment)
    {
        return $payment->charge(100);
    }
}

🔹 Step 3: এখন টেস্টে এই সার্ভিসকে Mock করব

namespace Tests\Feature;

use Tests\TestCase;
use App\Services\PaymentService;
use Illuminate\Support\Facades\App;

class PaymentTest extends TestCase
{
    public function test_payment_service_mock()
    {
        // 1. মক অবজেক্ট তৈরি করুন
        $mock = \Mockery::mock(PaymentService::class);

        // 2. মক মেথডের প্রত্যাশিত রিটার্ন ভ্যালু সেট করুন
        $mock->shouldReceive('charge')
             ->with(100)
             ->once()
             ->andReturn('Mocked Payment Success!');

        // 3. Laravel container-এ bind করুন
        $this->app->instance(PaymentService::class, $mock);

        // 4. এখন Controller call করলে Mock কাজ করবে
        $response = $this->get('/pay');

        $response->assertStatus(200);
        $response->assertSee('Mocked Payment Success!');
    }
}

এই টেস্টে আসল charge() মেথড কল হয় না, বরং আমরা যেভাবে চাই সেভাবে response পাই।

✅ আরও কিছু জিনিস আপনি Mock করতে পারেন:

✅ Example: HTTP Request Mock (Laravel HTTP client)

use Illuminate\Support\Facades\Http;

public function test_api_call_mock()
{
    Http::fake([
        'api.example.com/*' => Http::response(['success' => true], 200),
    ]);

    $response = Http::get('https://api.example.com/data');

    $this->assertTrue($response->json()['success']);
}

🔚 সংক্ষেপে:

✅ প্রশ্ন ১১: Laravel অ্যাপ্লিকেশনের পারফরম্যান্স (Performance) উন্নত করার জন্য কোন কোন কৌশল ব্যবহার করা যায়? ব্যাখ্যা করুন।

✅ উত্তর:

Laravel অনেক ফিচার সমৃদ্ধ একটি ফ্রেমওয়ার্ক, কিন্তু ভুলভাবে কোড করলে এটি ধীরগতির (slow) হতে পারে। নিচে কিছু গুরুত্বপূর্ণ কৌশল দেওয়া হলো যা অ্যাপকে দ্রুততর করতে সাহায্য করবে।

🚀 1. Eager Loading ব্যবহার করুন (N+1 সমস্যা এড়াতে)

🔸 সমস্যাঃ

$users = User::all(); // প্রতিটি ইউজারের সাথে profile দরকার
foreach ($users as $user) {
    echo $user->profile->bio;
}

এই ক্ষেত্রে প্রতিটি user-এর জন্য আলাদা query চলে — এটাকে বলে N+1 problem।

✅ সমাধানঃ

$users = User::with('profile')->get();

🚀 2. Cache ব্যবহার করুন

🔸 Page Cache:

Cache::put('homepage', $data, 3600); // ১ ঘণ্টা পর্যন্ত cache থাকবে

🔸 Route Cache:

php artisan route:cache

🔸 Config Cache:

php artisan config:cache

🚀 3. Query Optimization করুন

বড় query split করে ছোট ছোট করুন।
select * এড়িয়ে প্রয়োজনীয় column গুলো select করুন:

User::select('id', 'name')->get();

Index তৈরি করুন DB column-এ (search/filter এর ক্ষেত্রে)।

🚀 4. Queue ব্যবহার করুন

Time-consuming কাজ যেমন ইমেইল, রিপোর্ট জেনারেশন ইত্যাদি Queue-তে পাঠিয়ে দিন।

dispatch(new SendWelcomeEmail($user));

🚀 5. Pagination ব্যবহার করুন

অনেক ডেটা একসাথে লোড না করে paginate করুন:

User::paginate(20);

🚀 6. Lazy Collections ব্যবহার করুন

Laravel-এর Lazy Collection বড় Dataset-এর জন্য memory-efficient:

User::cursor()->each(function ($user) {
    // Memory কম ব্যবহার হবে
});

🚀 7. View / Blade Cache (Compiled View)

Blade ফাইলগুলো Compile হয়ে Storage-এ সেভ হয়। Faster rendering-এর জন্য:

php artisan view:cache

🚀 8. Database Connection & Pooling

.env ফাইলে যথাযথ DB config দিন।
যদি high traffic অ্যাপ হয়, database connection pooling ব্যবহার করুন (যেমনঃ Swoole, Octane)।

🚀 9. Laravel Octane ব্যবহার করুন (Advanced)

High performance অ্যাপ্লিকেশনের জন্য Laravel Octane ব্যবহার করতে পারেন:

Swoole / RoadRunner ব্যবহার করে।
Laravel request lifecycle পুনরায় load না করে দ্রুততর করে তোলে।

🚀 10. Autoload Optimization

Production mode-এ class autoload অপ্টিমাইজ করুন:

composer install --optimize-autoloader --no-dev

🚀 11. Redis বা Memcached Cache Driver ব্যবহার করুন

ডিফল্ট file cache-এর বদলে Redis ব্যবহার করলে অনেক দ্রুত performance পাওয়া যায়।

.env ফাইলে:

CACHE_DRIVER=redis
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis

🚀 12. Assets অপ্টিমাইজ করুন (JS/CSS)

Mix বা Vite দিয়ে JS/CSS minify করুন:

npm run prod

🧠 সংক্ষেপে পারফরম্যান্স টিপস টেবিলে:

✨ অতিরিক্ত পরামর্শ:

Debugbar ব্যবহার করে Performance bottleneck খুঁজে বের করুন।
.env ফাইলে APP_DEBUG=false করুন production-এ।

✅ প্রশ্ন ১২: Laravel-এ আপনি কীভাবে Caching ইমপ্লিমেন্ট করবেন? এবং কোন কোন ধরণের Cache মেকানিজম Laravel-এ পাওয়া যায়?

✅ উত্তর:

🧠 Caching কী?

Caching হলো একটি অস্থায়ী ডেটা সংরক্ষণের পদ্ধতি যাতে বারবার একি ডেটা পুনরায় ডাটাবেজ বা API থেকে না আনতে হয়। এর ফলে অ্যাপ্লিকেশনের পারফরম্যান্স বৃদ্ধি পায় এবং লোড কমে।

🛠️ Laravel-এ Cache ব্যবহারের সাধারণ নিয়ম

Laravel-এ Cache ব্যবহারের জন্য Cache Facade ব্যবহার করা হয়।

✅ 1. Cache সংরক্ষণ করা (Store Cache)

use Illuminate\Support\Facades\Cache;

Cache::put('key', 'value', $seconds = 3600); // ১ ঘণ্টার জন্য সংরক্ষণ

✅ 2. Cache থেকে ডেটা পাওয়া (Retrieve Cache)

$value = Cache::get('key'); // value পাবেন

✅ 3. ডিফল্ট ভ্যালু সহ Cache পড়া

$value = Cache::get('key', 'default_value');

✅ 4. Cache থাকলে return, না থাকলে তৈরি করুন

$value = Cache::remember('users', 3600, function () {
    return DB::table('users')->get();
});

✅ 5. চিরস্থায়ী Cache (forever)

Cache::forever('site_name', 'My Website');

✅ 6. Cache মুছে ফেলা (Delete Cache)

Cache::forget('key');

✅ 7. সব Cache Clear করা

php artisan cache:clear

🔄 Route, Config ও View Cache:

🔹 Route Cache:

php artisan route:cache

🔹 Config Cache:

php artisan config:cache

🔹 View Cache:

php artisan view:cache

🚀 Laravel-এ যে Caching Mechanism/Driver গুলো পাওয়া যায়:

Laravel এর .env ফাইলে

CACHE_DRIVER

দিয়ে নির্ধারণ করা হয় আপনি কোন সিস্টেম ব্যবহার করছেন।

CACHE_DRIVER=file

✅ ১. file (ডিফল্ট):

Storage ফোল্ডারে ফাইল আকারে cache সংরক্ষণ করে।

✅ ২. database:

Cache data ডাটাবেজে সংরক্ষণ করে।

php artisan cache:table
php artisan migrate

✅ ৩. array:

শুধুমাত্র current request এর জন্য RAM-এ cache রাখে (testing purpose)।

✅ ৪. redis:

Very fast, scalable memory-based caching system (production recommendation)।

✅ ৫. memcached:

Lightweight distributed caching system (alternative to Redis)।

🎯 ব্যবহার উপযোগিতা অনুযায়ী Driver নির্বাচন:

🧪 উদাহরণ: Redis Cache ব্যবহার

.env ফাইলে:

CACHE_DRIVER=redis

config/database.php-এ Redis কানফিগার নিশ্চিত করতে হবে।

🧠 চাকরির ইন্টারভিউ টিপস:

"Production অ্যাপ্লিকেশনে আপনি কোন cache ব্যবহার করবেন?"
উত্তর: Redis, কারণ এটি in-memory, super fast এবং scalable।

✅ সংক্ষেপে Laravel Caching:

✅ প্রশ্ন ১৩: Laravel-এ RESTful API তৈরি করার ধাপগুলো কী কী? প্রসেস ব্যাখ্যা করুন।

✅ উত্তর:

🧠 RESTful API কী?

REST (Representational State Transfer) হলো ওয়েব সার্ভিস ডিজাইনের একটি স্টাইল, যা HTTP মেথড (GET, POST, PUT, DELETE) ব্যবহার করে ডেটা রিসোর্স ম্যানেজ করে।
Laravel-এ RESTful API তৈরি করা খুব সহজ ও শক্তিশালী।

🚀 Laravel-এ RESTful API তৈরি করার ধাপগুলো:

১. রাউট তৈরি করা (Routes)

Laravel-এ API রাউটগুলো routes/api.php ফাইলে সংজ্ঞায়িত করা হয়।

Route::apiResource('posts', PostController::class);

apiResource স্বয়ংক্রিয়ভাবে ৭টি RESTful রাউট তৈরি করে (index, show, store, update, destroy)।

২. কন্ট্রোলার তৈরি (Controller)

php artisan make:controller PostController --api

--api ফ্ল্যাগ দিয়ে কন্ট্রোলার তৈরি করলে create/edit view মেথড থাকে না, কারণ API শুধু ডেটা হ্যান্ডেল করে।

৩. মডেল ও মাইগ্রেশন তৈরি (Model & Migration)

php artisan make:model Post -m

মডেল Post ও সংশ্লিষ্ট মাইগ্রেশন ফাইল তৈরি হবে।
মাইগ্রেশন ফাইলে টেবিল কাঠামো ডিফাইন করুন:

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->timestamps();
});

php artisan migrate

৪. কন্ট্রোলারে ফাংশন ইমপ্লিমেন্ট করা

use App\Models\Post;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function index()
    {
        return Post::all();  // সব পোস্ট দেখাবে
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'title' => 'required|string',
            'content' => 'required|string',
        ]);
        $post = Post::create($validated);

        return response()->json($post, 201);
    }

    public function show($id)
    {
        return Post::findOrFail($id);
    }

    public function update(Request $request, $id)
    {
        $post = Post::findOrFail($id);

        $validated = $request->validate([
            'title' => 'sometimes|required|string',
            'content' => 'sometimes|required|string',
        ]);

        $post->update($validated);

        return response()->json($post);
    }

    public function destroy($id)
    {
        Post::destroy($id);

        return response()->json(null, 204);
    }
}

৫. API Resource বা Resource Collections (Optional)

উন্নত JSON response এর জন্য Laravel Resource ব্যবহার করতে পারেন:

php artisan make:resource PostResource

use App\Http\Resources\PostResource;

public function show($id)
{
    $post = Post::findOrFail($id);
    return new PostResource($post);
}

৬. API Authentication (Optional)

API টোকেন বা Passport/ Sanctum দিয়ে নিরাপত্তা নিশ্চিত করতে পারেন।

৭. Test API

Postman, Insomnia বা অন্য কোনো API client দিয়ে আপনার API endpoint গুলো টেস্ট করুন।

🔥 সংক্ষেপে RESTful API তৈরি করার ধাপ:

🔚 উপসংহার:

Laravel-এ RESTful API বানানো খুবই সহজ এবং শক্তিশালী। Route, Controller, Model, Validation ও Response handling-এ Laravel এর বিল্ট-ইন সুবিধা API ডেভেলপমেন্টকে অনেক দ্রুততর করে দেয়।

✅ প্রশ্ন ১৪: API Resources কী, এবং Laravel-এ আপনি কীভাবে এগুলো ব্যবহার করবেন?

✅ উত্তর:

🧠 API Resources কী?

Laravel API Resources হলো JSON রেসপন্স ফরম্যাট করার একটি সুবিধাজনক পদ্ধতি।
এগুলো ডেটাকে কাঠামোগত, পরিষ্কার এবং কাস্টমাইজড আকারে API রেসপন্স হিসেবে রিটার্ন করতে সাহায্য করে।

কেন API Resource ব্যবহার করবেন?

API রেসপন্সে শুধু প্রয়োজনীয় ডেটা দেখাতে পারবেন।
ডেটার ফরম্যাট কন্ট্রোল করতে পারবেন।
Response consistency বজায় থাকে।
Complex nested relationship গুলো সহজে ম্যানেজ করা যায়।

🔧 Laravel-এ API Resource তৈরি ও ব্যবহার করার ধাপ:

১. Resource ক্লাস তৈরি করা

php artisan make:resource PostResource

২. Resource ক্লাসে ডেটা ফরম্যাট করা

app/Http/Resources/PostResource.php ফাইলে:

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class PostResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id'       => $this->id,
            'title'    => $this->title,
            'content'  => $this->content,
            'created_at' => $this->created_at->format('Y-m-d H:i:s'),
        ];
    }
}

৩. Controller-এ Resource ব্যবহার করা

use App\Http\Resources\PostResource;
use App\Models\Post;

class PostController extends Controller
{
    public function show($id)
    {
        $post = Post::findOrFail($id);
        return new PostResource($post);
    }

    public function index()
    {
        $posts = Post::all();
        return PostResource::collection($posts);
    }
}

৪. Nested Resource ব্যবহার (Optional)

public function toArray($request)
{
    return [
        'id'      => $this->id,
        'title'   => $this->title,
        'author'  => new UserResource($this->whenLoaded('author')),
    ];
}

➕ Collection Resource

Laravel Resource Collections ব্যবহার করলে একাধিক রিসোর্সের জন্য কাস্টম লজিক যোগ করতে পারবেন।

php artisan make:resource PostCollection

🧠 সংক্ষেপে:

✅ প্রশ্ন ১৫: Laravel কীভাবে Exception (ত্রুটি) হ্যান্ডেল করে? এবং কীভাবে আপনি বিভিন্ন Exception-এর জন্য কাস্টম এরর পেজ বানাতে পারেন?

✅ উত্তর:

🧠 Laravel-এ Exception Handling কীভাবে কাজ করে?

Laravel এর Exception Handling মেকানিজম খুবই শক্তিশালী এবং ফ্লেক্সিবল।
এটি app/Exceptions/Handler.php ফাইলে মূলত হ্যান্ডেল করা হয়।

🛠️ Exception Handling এর মূল উপাদান:

১. report() method

Exception লগ করার জন্য ব্যবহৃত হয় (Laravel ডিফল্টভাবে Log ফাইলে লেখে)।
আপনি এখানে কাস্টম Exception লগ বা ৩য় পক্ষের সিস্টেমে যেমন Sentry, Bugsnag ইত্যাদিতে পাঠাতে পারেন।

public function report(Throwable $exception)
{
    parent::report($exception);
}

২. render() method

Exception ক্যাপচার করে HTTP Response তৈরি করে।
এখানে আপনি Exception অনুযায়ী আলাদা ভিউ বা JSON রেসপন্স দিতে পারেন।

public function render($request, Throwable $exception)
{
    return parent::render($request, $exception);
}

✅ কাস্টম Exception হ্যান্ডলিং এবং এরর পেজ বানানো:

১. কাস্টম Exception তৈরি করা

php artisan make:exception CustomException

app/Exceptions/CustomException.php:

namespace App\Exceptions;

use Exception;

class CustomException extends Exception
{
    public function render($request)
    {
        return response()->view('errors.custom', [], 500);
    }
}

২. Handler.php-তে Exception আলাদাভাবে হ্যান্ডল করা

public function render($request, Throwable $exception)
{
    if ($exception instanceof \App\Exceptions\CustomException) {
        return response()->view('errors.custom', [], 500);
    }

    return parent::render($request, $exception);
}

৩. ভিন্ন Exception-র জন্য আলাদা পেজ তৈরি করা

Laravel এ ডিফল্টভাবে কিছু error view থাকে resources/views/errors/ ফোল্ডারে যেমন:

404.blade.php (Not Found)
500.blade.php (Server Error)
403.blade.php (Forbidden)
419.blade.php (CSRF Token Mismatch)

আপনি এগুলো কাস্টমাইজ করে নিজের মতো করতে পারেন।

৪. API Response এর জন্য Exception হ্যান্ডেল করা

public function render($request, Throwable $exception)
{
    if ($request->wantsJson()) {
        if ($exception instanceof ModelNotFoundException) {
            return response()->json(['error' => 'Resource not found'], 404);
        }
        return response()->json(['error' => 'Server Error'], 500);
    }

    return parent::render($request, $exception);
}

🔥 Laravel Exception Handling Summary:

➕ সংক্ষেপে:

Laravel exception গুলো central Handler.php-তে ধরা হয়।
আপনি নিজস্ব Exception class বানিয়ে আলাদা হ্যান্ডল করতে পারেন।
ভিন্ন HTTP status code বা JSON response তৈরি করতে পারেন।
ভিউ ফাইল কাস্টমাইজ করে error page সুন্দর করতে পারবেন।

✅ প্রশ্ন ১৬: Laravel-এ Logging System কীভাবে কাজ করে? এবং কীভাবে আপনি বিভিন্ন Log Channel কনফিগার করবেন?

✅ উত্তর:

🧠 Laravel Logging System কী?

Laravel এর Logging সিস্টেম মূলত Monolog লাইব্রেরি ব্যবহার করে, যা একটি জনপ্রিয় PHP logging লাইব্রেরি।

Laravel Logging সিস্টেম ডেভেলপারদের ডিবাগ, এরর ট্র্যাকিং এবং ইনফরমেশন লগ করার জন্য সুবিধাজনক ব্যবস্থা দেয়।

🛠️ Laravel-এ Logging এর মূল বৈশিষ্ট্য:

সহজে লগ লেখা (info, warning, error, debug, critical ইত্যাদি)
একাধিক Channel ব্যবহার করার সুযোগ (একই সাথে ফাইল, সিস্টেম লগ, Slack ইত্যাদিতে পাঠানো)
বিভিন্ন কনফিগারেশন অপশন সহজে পরিবর্তনযোগ্য
Custom Channel তৈরি করার সুবিধা

🔍 Laravel এ Log ব্যবহার করার মৌলিক পদ্ধতি

use Illuminate\Support\Facades\Log;

Log::info('This is an info log');
Log::warning('This is a warning log');
Log::error('This is an error log');

⚙️ Log Channel কনফিগারেশন

Laravel এর লগ কনফিগারেশন config/logging.php ফাইলে থাকে।

১. Default Log Channel

.env ফাইলে ডিফল্ট চ্যানেল সেট করা হয়:

LOG_CHANNEL=stack

২. প্রধান কিছু Log Channel:

৩. উদাহরণ: Stack Channel কনফিগারেশন

config/logging.php থেকে:

'channels' => [
    'stack' => [
        'driver' => 'stack',
        'channels' => ['daily', 'slack'],
        'ignore_exceptions' => false,
    ],
    'daily' => [
        'driver' => 'daily',
        'path' => storage_path('logs/laravel.log'),
        'level' => 'debug',
        'days' => 14,
    ],
    'slack' => [
        'driver' => 'slack',
        'url' => env('LOG_SLACK_WEBHOOK_URL'),
        'username' => 'Laravel Log',
        'emoji' => ':boom:',
        'level' => 'critical',
    ],
],

৪. Log Level গুলো:

emergency
alert
critical
error
warning
notice
info
debug

৫. Custom Channel তৈরি করা

'channels' => [
    'custom' => [
        'driver' => 'monolog',
        'handler' => Monolog\Handler\StreamHandler::class,
        'with' => [
            'stream' => storage_path('logs/custom.log'),
        ],
        'level' => 'debug',
    ],
],

🧠 Laravel Logging ব্যবহার উদাহরণ:

Log::debug('Debug message');
Log::info('User logged in', ['user_id' => $user->id]);
Log::error('Something went wrong!');

➕ সংক্ষেপে:

Logging System -> Monolog লাইব্রেরি ব্যবহার করে Laravel logging করে
Log Channel -> লগ লেখা কোথায় হবে তার নির্দেশনা (file, slack, syslog ইত্যাদি)
Default Channel -> .env থেকে নির্ধারণ করা হয়
Stack Channel -> একাধিক channel একই সাথে ব্যবহার করা যায়
Log Levels -> error, warning, info, debug ইত্যাদি
Custom Channel -> নিজের মতো করে কাস্টম লগ চ্যানেল তৈরি করা যায়

✅ প্রশ্ন ১৭: Laravel অ্যাপলিকেশন ডেপ্লয় করার প্রক্রিয়া ব্যাখ্যা করুন। আপনি কোন টুল বা পদ্ধতি ব্যবহার করবেন?

✅ উত্তর:

🧠 Laravel অ্যাপ ডেপ্লয়মেন্ট কী?

ডেপ্লয়মেন্ট মানে হলো আপনার Laravel অ্যাপকে লোকাল মেশিন থেকে লাইভ সার্ভার/প্রোডাকশন সার্ভারে স্থানান্তর করা, যাতে ইউজাররা অ্যাক্সেস করতে পারে।

🔧 Laravel ডেপ্লয়মেন্টের ধাপসমূহ (সাধারণ নিয়ম):

🔹 ১. প্রোডাকশন সার্ভার প্রস্তুত করা

আপনি সার্ভার হিসেবে ব্যবহার করতে পারেন:

Shared Hosting
VPS/Cloud Server (e.g., DigitalOcean, AWS, Linode)
Platform as a Service (PaaS) – যেমন Heroku, Laravel Forge

প্রয়োজনীয় সফটওয়্যার:

PHP (>=8.1)
MySQL / MariaDB
Nginx বা Apache
Composer
Laravel CLI

🔹 ২. কোড আপলোড করা

২টি জনপ্রিয় উপায়:

(ক) Git ব্যবহার করে (রেকমেন্ডেড)

git clone https://github.com/your-repo.git

(খ) FTP/SFTP বা cPanel File Manager দিয়ে কোড আপলোড করা

🔹 ৩. Environment সেটআপ (.env ফাইল কনফিগার)

প্রোডাকশন সার্ভারের জন্য .env ফাইল তৈরি করুন:

APP_ENV=production
APP_DEBUG=false
APP_URL=https://yourdomain.com

DB_HOST=127.0.0.1
DB_DATABASE=your_db
DB_USERNAME=root
DB_PASSWORD=secret

🔹 ৪. ডিপেনডেন্সি ইন্সটল করা

composer install --optimize-autoloader --no-dev

--no-dev → ডেভেলপমেন্ট প্যাকেজ ইনস্টল হবে না
--optimize-autoloader → ক্লাসলোডার অপটিমাইজ করে

🔹 ৫. APP Key জেনারেট করা

php artisan key:generate

🔹 ৬. Storage Permission দেওয়া

chmod -R 775 storage
chmod -R 775 bootstrap/cache

🔹 ৭. মাইগ্রেশন চালানো

php artisan migrate --force

--force দিয়ে নিশ্চিত করে প্রোডাকশন সার্ভারে মাইগ্রেশন হবে

🔹 ৮. ক্যাশ অপটিমাইজ করা

php artisan config:cache
php artisan route:cache
php artisan view:cache

🔹 ৯. Queue Worker চালানো (যদি queue ব্যবহার করেন)

php artisan queue:work

বা Supervisor দিয়ে manage করুন।

🛠️ Laravel Deployment Tools (পছন্দ অনুযায়ী):

🧪 Deployment Checklist (সংক্ষেপে):

ধাপ কাজ
✅ Server Setup -> PHP, DB, Composer ইনস্টল
✅ Code Upload -> Git clone / FTP
✅ .env Config -> Production অনুযায়ী
✅ Composer Install -> Dependencies ইনস্টল
✅ Storage Permission -> লেখার পারমিশন দিন
✅ DB Migrate -> Artisan দিয়ে
✅ Optimize -> config, route, view cache
✅ Supervisor (Queue) -> worker চালু করুন (যদি প্রযোজ্য হয়)

🏁 উপসংহার:

Laravel অ্যাপ ডেপ্লয় করতে হলে আপনাকে শুধু কোড হোস্ট করলেই হবে না, বরং সঠিকভাবে সার্ভার সেটআপ, .env কনফিগার, পারমিশন, মাইগ্রেশন, ক্যাশ এবং পারফরম্যান্স অপটিমাইজ করাও খুব গুরুত্বপূর্ণ।

✅ প্রশ্ন ১৮: Laravel-এ environment-specific configuration কীভাবে হ্যান্ডেল করা হয়?

✅ উত্তর:

🧠 Environment-specific configuration মানে কী?

Laravel অ্যাপটি বিভিন্ন পরিবেশে (environment) কাজ করতে পারে — যেমন:

local (ডেভেলপমেন্ট)
staging (পরীক্ষা)
production (লাইভ)

Environment-specific configuration মানে প্রতিটি environment অনুযায়ী আলাদা আলাদা সেটিংস ব্যবহার করা।

🔧 Laravel কীভাবে Environment ডিফাইন করে?

Laravel APP_ENVvariable ব্যবহার করে environment চিনে।

📁 .env ফাইলে আপনি সেট করতে পারেন:

APP_ENV=local

📁 .env ফাইল ব্যবহার করে কনফিগারেশন ম্যানেজমেন্ট

.env ফাইল Laravel অ্যাপের গোপন ও পরিবেশ-নির্ভর তথ্য সংরক্ষণ করে। যেমন:

APP_NAME=MyApp
APP_ENV=production
APP_KEY=base64:...
APP_DEBUG=false
APP_URL=https://example.com

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=myapp
DB_USERNAME=root
DB_PASSWORD=secret

🔄 এই .env ফাইল থেকে কনফিগারেশন কিভাবে পাওয়া যায়?

Laravel এর কনফিগ ফাইলগুলো (যেমন config/app.php, config/database.php) .env থেকে env() ফাংশনের মাধ্যমে মান নিয়ে আসে।

উদাহরণ:

'debug' => env('APP_DEBUG', false),

🗂️ Environment Specific Config ব্যবহার করার উপায়:
✅ ১. বিভিন্ন .env ফাইল তৈরি করা (স্টেজ অনুযায়ী)

.env         ← local environment
.env.staging ← staging server
.env.production ← live server

✅ ২. Git-এ .env ফাইল রাখা উচিত না

.gitignore ফাইলে .env রাখা থাকে, যেন এটা version control-এ না যায়।

🛠️ Environment Configuration ব্যবহারের ব্যবহারিক ক্ষেত্র:

✅ চাইলে কোডের ভিতরে environment চেক করতেও পারেন

if (app()->environment('local')) {
    // Local environment-specific logic
}

বা

if (App::environment(['staging', 'production'])) {
    // For both staging and production
}

🔄 কনফিগারেশন ক্যাশ ক্লিয়ার এবং রিফ্রেশ করার কমান্ড:

php artisan config:clear
php artisan config:cache

🧪 উপসংহার (Summary):

✅ প্রশ্ন ১৯: ওয়েব অ্যাপ্লিকেশনে সাধারণ সিকিউরিটি দুর্বলতাগুলোর আলোচনা করুন এবং Laravel কীভাবে এই ঝুঁকিগুলো প্রতিরোধ করে তা ব্যাখ্যা করুন।

✅ উত্তর:

🔐 সাধারণ ওয়েব সিকিউরিটি ভলনারেবিলিটি (Vulnerabilities):

ওয়েব অ্যাপ্লিকেশন সাধারণত নিচের নিরাপত্তা সমস্যার মুখোমুখি হয়:

✅ Laravel কীভাবে এসব সমস্যার সমাধান করে:

🔐 ১. SQL Injection – সমাধান: Eloquent ও Query Builder

Laravel এর Eloquent ORM এবং Query Builder ব্যবহার করলে ডিফল্টভাবে prepared statements তৈরি হয়।

// নিরাপদ
$user = DB::table('users')->where('email', $email)->first();

🔰 ইনপুট সরাসরি SQL তে বসালে ইনজেকশন হয় না।

🔐 ২. XSS (Cross-site scripting) – সমাধান: Blade Escaping

Laravel এর Blade টেমপ্লেট ইঞ্জিন স্বয়ংক্রিয়ভাবে HTML encode করে:

{{ $userInput }} {{-- নিরাপদ --}}
{!! $userInput !!} {{-- সাবধানে ব্যবহার করতে হবে --}}

🔰 Blade এ {{ }} ব্যবহার করলে JavaScript ইনজেকশন প্রতিরোধ হয়।

🔐 ৩. CSRF (Cross-site request forgery) – সমাধান: CSRF Token

Laravel স্বয়ংক্রিয়ভাবে ফর্মে CSRF টোকেন যুক্ত করে:

<form method="POST" action="/submit">
    @csrf
</form>

🔰 Laravel এর middleware VerifyCsrfToken এই টোকেন যাচাই করে।

🔐 ৪. Mass Assignment – সমাধান: Fillable বা Guarded

Laravel এ mass assignment থেকে রক্ষা করতে fillable বা guarded প্রপার্টি ব্যবহার করা হয়।

// সঠিক
protected $fillable = ['name', 'email'];

// না চাইলে সব ব্লক
protected $guarded = ['is_admin'];

🔰 এটা prevents করে ইউজার ইনপুট থেকে অবাঞ্ছিত ফিল্ড আপডেট হওয়া।

🔐 ৫. Password Hashing – সমাধান: bcrypt / Hash ফ্যাসাড

Laravel এ পাসওয়ার্ড এনক্রিপ্ট করার জন্য bcrypt() বা Hash ফ্যাসাড ব্যবহার করা হয়।

use Illuminate\Support\Facades\Hash;

$user->password = Hash::make($request->password);

🔰 পাসওয়ার্ড কখনো প্লেইন টেক্সটে সংরক্ষণ করা উচিত না।

🔐 ৬. File Upload Protection

Laravel ফাইল আপলোড করার সময় মাইম টাইপ, এক্সটেনশন, ও ফাইল সাইজ যাচাই করার সুবিধা দেয়।

$request->validate([
    'photo' => 'required|image|mimes:jpg,png,jpeg|max:2048',
]);

🔰 এই ভ্যালিডেশন ম্যালিসিয়াস স্ক্রিপ্ট বা exe ফাইল ব্লক করে।

🔐 ৭. Secure Redirects

Laravel এর redirect() ফাংশন শুধু অনুমোদিত URL-এ পাঠাতে সাহায্য করে।

return redirect()->intended('/dashboard');

🔰 আপনার ইচ্ছেমতো রিডিরেক্ট না করে, এটি আগে নির্ধারিত route এ পাঠায়।

✨ Laravel আরও যেসব নিরাপত্তা সুবিধা দেয়:

🧪 উপসংহার:

Laravel ডেভেলপারদের সিকিউরিটি নিয়ে সচেতন থাকতে হয় এবং Laravel-এর বিল্ট-ইন সুবিধাগুলো ঠিকভাবে ব্যবহার করলেই অনেক নিরাপত্তা ঝুঁকি দূর হয়।

✅ প্রশ্ন ২০: Laravel অ্যাপ্লিকেশনে SQL Injection আক্রমণ প্রতিরোধে আপনি কী কী ব্যবস্থা নেবেন?

✅ উত্তর:

🔍 SQL Injection কী?

SQL Injection হলো একটি ভালনারেবিলিটি, যেখানে ইউজার ইনপুটের মাধ্যমে ডাটাবেজে ক্ষতিকর SQL কমান্ড ইনজেক্ট করা যায়। এর মাধ্যমে হ্যাকার:

ডাটা চুরি করতে পারে
ডাটা মুছে ফেলতে পারে
অথরাইজড না হয়েও ডাটাবেজ অ্যাক্সেস করতে পারে

🔐 Laravel কীভাবে SQL Injection থেকে রক্ষা করে?

Laravel ডিফল্টভাবে SQL Injection প্রতিরোধ করে নিচের টেকনিকগুলো ব্যবহার করে:

✅ ১. Eloquent ORM ব্যবহার করা

Eloquent ব্যবহার করলে ইনপুট স্বয়ংক্রিয়ভাবে bind হয়, যেখানে injection সম্ভব হয় না।

// নিরাপদ
$user = User::where('email', $request->email)->first();

🔒 এখানে $request->email ডিরেক্ট SQL-এ না গিয়ে bind হয়ে যায়।

✅ ২. Query Builder ব্যবহার করা

Laravel এর Query Builder where() ইত্যাদি মেথড ব্যবহার করলে prepared statements তৈরি হয়।

$user = DB::table('users')->where('name', $request->name)->get();

🔒 এখানেও $request->name SQL string হিসেবে ইনজেক্ট হতে পারে না।

🚫 ৩. Raw SQL ব্যবহার করলে bind করতে হবে

যদি আপনি raw SQL চালাতে চান, তাহলে parameter binding ব্যবহার করতে হবে।

// ❌ ঝুঁকিপূর্ণ: ইউজার ইনপুট ডিরেক্ট বসানো হয়েছে
DB::select("SELECT * FROM users WHERE name = '$name'");

// ✅ নিরাপদ (bindings সহ)
DB::select("SELECT * FROM users WHERE name = ?", [$name]);

✅ ৪. Mass Assignment প্রতিরোধ

Mass assignment থেকে SQL injection হতে পারে যদি আপনি $fillable/$guarded না ব্যবহার করেন।

// ✅ নিরাপদ
protected $fillable = ['name', 'email'];

🔒 না দিলে malicious ফর্ম ইনপুট sensitive ফিল্ডে ইনজেক্ট হতে পারে।

✅ ৫. Request Validation ব্যবহার করা

ফর্ম ইনপুট ভ্যালিড না হলে তা SQL-এ পৌঁছানোর আগেই ব্লক হয়ে যায়।

$request->validate([
    'email' => 'required|email',
    'name' => 'required|string|max:255',
]);

✅ ৬. Stored Procedure ও ORM মিলিয়ে ব্যবহার করা (Optional Advanced)

Laravel থেকে ডাটাবেজের stored procedures ব্যবহার করা যায়, যাতে সরাসরি ইনজেকশন প্রতিরোধ হয়।

DB::statement('CALL safeProcedure(?, ?)', [$val1, $val2]);

🧪 সংক্ষেপে প্রতিরোধমূলক ব্যবস্থা:

🏁 উপসংহার:

Laravel এর ডিফল্ট ORM ও Query Builder ব্যবহার করলে আপনি SQL Injection থেকে অনেকটাই নিরাপদ। তবে কখনো raw SQL ব্যবহার করলে অবশ্যই bindings ব্যবহার করতে হবে। এবং সর্বদা ভ্যালিডেশন, ফিল্টারিং, ও সঠিক মডেল ফিল্ড নিয়ন্ত্রণ করা উচিত।

✅ প্রশ্ন ২১: একটি PHP ফাংশন লিখুন যা একটি সংখ্যার সেট থেকে সব সম্ভাব্য কম্বিনেশন খুঁজে বের করে যেগুলোর যোগফল একটি নির্দিষ্ট টার্গেটের সমান হয়। নিশ্চিত করুন যে এটি বড় ইনপুট অ্যারে হ্যান্ডেল করতে দক্ষতার সাথে কাজ করে।

উদাহরণ:

ইনপুট: [2, 3, 5, 7], target = 8  
আউটপুট: [[3, 5], [2, 3, 3]]

✅ উত্তর:

✅ সমাধান (PHP কোড সহ):

আমরা এখানে ব্যাকট্র্যাকিং ও মেমোইজেশন ব্যবহার করব যাতে কম্বিনেশন খুঁজে বের করতে পারি এবং বারবার একই উপসমস্যা না করি।

function combinationSum(array $candidates, int $target): array {
    sort($candidates); // Optional but helps avoid duplicate combinations
    $result = [];
    $memo = [];

    function dfs($candidates, $target, $start, $path, &$result, &$memo) {
        $key = $target . '-' . implode(',', $path);
        if (isset($memo[$key])) return;

        if ($target == 0) {
            $result[] = $path;
            return;
        }

        for ($i = $start; $i < count($candidates); $i++) {
            if ($candidates[$i] > $target) break;

            dfs($candidates, $target - $candidates[$i], $i, array_merge($path, [$candidates[$i]]), $result, $memo);
        }

        $memo[$key] = true;
    }

    dfs($candidates, $target, 0, [], $result, $memo);
    return $result;
}

// ✅ উদাহরণ চালানো:
$candidates = [2, 3, 5, 7];
$target = 8;
print_r(combinationSum($candidates, $target));

🧠 কীভাবে কাজ করে:

dfs() ফাংশনটি রিকার্সিভলি প্রতিটি সম্ভাব্য সংখ্যার সমন্বয় পরীক্ষা করে।
একই সাব-প্রোব্লেম আবার না করতে memo অ্যারে ব্যবহার করছি।
start ইনডেক্স দিয়ে পরবর্তী রিকর্শনে পুনরাবৃত্তি নিয়ন্ত্রণ করা হয় যাতে ডুপ্লিকেট কম্বিনেশন না আসে।
যদি target == 0 হয়, তাহলে এটি একটি ভ্যালিড কম্বিনেশন এবং তা result এ যোগ করা হয়।

⚡️ বড় ইনপুটে পারফরম্যান্স টিপস:

sort() করলে লুপে আগেই বড় সংখ্যাগুলো বাদ দেয়া যায় (if ($candidates[$i] > $target) break;)
memoization এর ফলে একই কম্বিনেশন বারবার চেক করতে হয় না।

📤 উদাহরণ আউটপুট:

Array
(
    [0] => Array
        (
            [0] => 2
            [1] => 3
            [2] => 3
        )

    [1] => Array
        (
            [0] => 3
            [1] => 5
        )
)

✅ প্রশ্ন ২২: Laravel-এর Eloquent ORM ব্যবহার করে একটি কুয়েরি লিখুন যা নিচের তথ্য ফিরিয়ে দেয়:

গত ৩০ দিনের মধ্যে যেসব ইউজার $1,000+ অর্ডার করেছেন তাদের তালিকা
প্রত্যেক ইউজারের মোট অর্ডার অ্যামাউন্ট ও অর্ডার সংখ্যা
তাদের প্রোফাইল ও সর্বশেষ অর্ডার eager load করতে হবে

✅ উত্তর:

🧩 ধরা যাক আপনার মডেল গুলো এমন:

User মডেলের সাথে orders(), profile() রিলেশন আছে
Order মডেলের amount, created_at ফিল্ড আছে

✅ Laravel Eloquent ORM কোড:

use Illuminate\Support\Facades\DB;
use Carbon\Carbon;
use App\Models\User;

$users = User::whereHas('orders', function ($query) {
        $query->where('created_at', '>=', now()->subDays(30));
    })
    ->withSum(['orders' => function ($query) {
        $query->where('created_at', '>=', now()->subDays(30));
    }], 'amount')
    ->withCount(['orders' => function ($query) {
        $query->where('created_at', '>=', now()->subDays(30));
    }])
    ->with(['profile', 'orders' => function ($query) {
        $query->latest()->limit(1);
    }])
    ->get()
    ->filter(function ($user) {
        return $user->orders_sum_amount > 1000;
    });

🧠 কী হয়েছে এখানে:

📝 নোট:

orders_sum_amount এবং orders_count অটো জেনারেটেড ফিল্ড Laravel-এর withSum() ও withCount() থেকে আসে
এখানে আমরা only those users রাখছি যাদের গত ৩০ দিনের অর্ডার টোটাল > 1000

✅ উদাহরণ রিটার্ন ভ্যালু:

[
  {
    "id" => 1,
    "name" => "Ruhul Amin",
    "orders_sum_amount" => 1200,
    "orders_count" => 3,
    "profile" => [ ... ],
    "orders" => [
      [ "id" => 5, "amount" => 700, "created_at" => "..." ]
    ]
  },
  ...
]

✅ প্রশ্ন ২৩: Laravel-এ একটি কাস্টম সার্ভিস তৈরি করুন যা বিভিন্ন salary heads (যেমন: basic pay, allowances, deductions) ব্যবহার করে কর্মচারীদের মাসিক বেতন গণনা করবে।

সার্ভিসটি সার্ভিস কন্টেইনারে bind করুন
এটি একটি কন্ট্রোলারে inject করুন এবং ব্যবহার দেখান

✅ উত্তর:

✅ ধাপে ধাপে সমাধান

🔧 Step 1: কাস্টম সার্ভিস ক্লাস তৈরি করুন

php artisan make:service SalaryCalculatorService

🔽 বা নিজে তৈরি করুন:

📁 app/Services/SalaryCalculatorService.php

namespace App\Services;

class SalaryCalculatorService
{
    public function calculate(array $salaryData): float
    {
        $basic = $salaryData['basic'] ?? 0;
        $allowances = $salaryData['allowances'] ?? 0;
        $deductions = $salaryData['deductions'] ?? 0;

        $totalSalary = $basic + $allowances - $deductions;

        return max($totalSalary, 0); // নেগেটিভ হলে ০ রিটার্ন
    }
}

🧩 Step 2: সার্ভিস কন্টেইনারে bind করা

📁 app/Providers/AppServiceProvider.php

use App\Services\SalaryCalculatorService;

public function register(): void
{
    $this->app->bind(SalaryCalculatorService::class, function ($app) {
        return new SalaryCalculatorService();
    });
}

🧪 Step 3: কন্ট্রোলারে ইনজেক্ট করে ব্যবহার করা

php artisan make:controller EmployeeController

📁 app/Http/Controllers/EmployeeController.php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Services\SalaryCalculatorService;

class EmployeeController extends Controller
{
    protected $salaryCalculator;

    public function __construct(SalaryCalculatorService $salaryCalculator)
    {
        $this->salaryCalculator = $salaryCalculator;
    }

    public function calculateSalary(Request $request)
    {
        $salaryData = $request->only(['basic', 'allowances', 'deductions']);

        $monthlySalary = $this->salaryCalculator->calculate($salaryData);

        return response()->json([
            'monthly_salary' => $monthlySalary,
        ]);
    }
}

🔗 Step 4: রাউট যুক্ত করা

📁 routes/web.php (বা api.php)

use App\Http\Controllers\EmployeeController;

Route::post('/calculate-salary', [EmployeeController::class, 'calculateSalary']);

✅ উদাহরণ ইনপুট (POST Request):

{
  "basic": 20000,
  "allowances": 5000,
  "deductions": 3000
}

✅ Response:

{
  "monthly_salary": 22000
}

🧠 টিপস:

চাইলে আপনি SalaryCalculatorService-এ calculateAnnual() বা generatePayslip() মেথডও যোগ করতে পারেন।
সার্ভিসকে ইন্টারফেস দিয়ে bind করলেও ভালো practice হয়।

✅ প্রশ্ন ২৪: Laravel-এর Broadcasting ফিচার ব্যবহার করে একটি রিয়েল-টাইম Notification System তৈরি করুন।

একটি নতুন ব্লগ পোস্ট পাবলিশ হলে একটি Event ট্রিগার করুন
Pusher বা Laravel Echo দিয়ে সকল কানেক্টেড ইউজারকে তাৎক্ষণিক নোটিফিকেশন পাঠান

✅ উত্তর:

✅ ধাপে ধাপে সমাধান:

🔧 Step 1: Laravel Broadcast সাপোর্ট চালু

📄 .env ফাইলে যুক্ত করুন:

BROADCAST_DRIVER=pusher
PUSHER_APP_ID=your_app_id
PUSHER_APP_KEY=your_app_key
PUSHER_APP_SECRET=your_app_secret
PUSHER_APP_CLUSTER=mt1

📄 config/broadcasting.php:

'default' => env('BROADCAST_DRIVER', 'null'),

📦 Step 2: প্রয়োজনীয় প্যাকেজ ইনস্টল করুন

composer require pusher/pusher-php-server
npm install --save laravel-echo pusher-js

⚡️ Step 3: ইভেন্ট তৈরি করুন

php artisan make:event NewBlogPostPublished

📁 app/Events/NewBlogPostPublished.php

namespace App\Events;

use App\Models\Post;
use Illuminate\Broadcasting\Channel;
use Illuminate\Queue\SerializesModels;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class NewBlogPostPublished implements ShouldBroadcast
{
    use InteractsWithSockets, SerializesModels;

    public $post;

    public function __construct(Post $post)
    {
        $this->post = $post;
    }

    public function broadcastOn()
    {
        return new Channel('blog-posts');
    }

    public function broadcastAs()
    {
        return 'new-post';
    }
}

✍️ Step 4: পোস্ট পাবলিশে ইভেন্ট ট্রিগার করুন

📁 app/Http/Controllers/PostController.php

use App\Models\Post;
use App\Events\NewBlogPostPublished;

public function store(Request $request)
{
    $post = Post::create($request->all());

    broadcast(new NewBlogPostPublished($post))->toOthers();

    return response()->json(['message' => 'Post published!']);
}

🧪 Step 5: ফ্রন্টএন্ড (Laravel Echo + Pusher)

📄 resources/js/bootstrap.js বা resources/js/app.js

import Echo from 'laravel-echo';
import Pusher from 'pusher-js';

window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: import.meta.env.VITE_PUSHER_APP_KEY,
    cluster: import.meta.env.VITE_PUSHER_APP_CLUSTER,
    forceTLS: true
});

📄 Component বা Script-এ:

Echo.channel('blog-posts')
    .listen('.new-post', (e) => {
        console.log('🎉 নতুন পোস্ট:', e.post.title);
        alert('New Blog Post: ' + e.post.title);
    });

📡 Step 6: Laravel WebSocket চালু (Local Test এর জন্য)

composer require beyondcode/laravel-websockets
php artisan vendor:publish --provider="BeyondCode\LaravelWebSockets\WebSocketsServiceProvider"
php artisan migrate
php artisan websockets:serve

✅ উপসংহার:

🧠 অতিরিক্ত টিপস:

যদি আপনি লগইন ইউজারের জন্য ব্যক্তিগত চ্যানেল চান, তাহলে PrivateChannel ব্যবহার করুন।
উন্নত ব্যবস্থার জন্য Notification ক্লাস বা laravel-notification-channels ইউজ করা যায়।

✅ প্রশ্ন ২৫: Laravel-এ একটি custom validation rule তৈরি করুন যা Social Security Number (SSN) এর ফরম্যাট (যেমন 123-45-6789) যাচাই করবে।
পাশাপাশি, একই ফরম্যাট যাচাইয়ের জন্য একটি Raw PHP ফাংশন লিখুন।

✅ উত্তর:

🟦 ১) Laravel Custom Validation Rule

🔧 ধাপ ১: রুল তৈরি করুন

php artisan make:rule ValidSSN

📁 app/Rules/ValidSSN.php

namespace App\Rules;

use Illuminate\Contracts\Validation\Rule;

class ValidSSN implements Rule
{
    public function passes($attribute, $value)
    {
        // Valid SSN format: 123-45-6789
        return preg_match('/^\d{3}-\d{2}-\d{4}$/', $value);
    }

    public function message()
    {
        return 'The :attribute must be a valid SSN format (e.g. 123-45-6789).';
    }
}

📥 ধাপ ২: রুল ব্যবহার করুন ফর্ম রিকুয়েস্ট বা কন্ট্রোলারে

✅ উদাহরণ – Controller:

use App\Rules\ValidSSN;

public function store(Request $request)
{
    $request->validate([
        'ssn' => ['required', new ValidSSN()],
    ]);

    // valid হলে ডেটা সেভ করুন
}

🟩 ২) Raw PHP Function (SSN ফরম্যাট যাচাই)

function isValidSSN($ssn)
{
    return preg_match('/^\d{3}-\d{2}-\d{4}$/', $ssn);
}

// ✅ উদাহরণ
$ssn1 = "123-45-6789";
$ssn2 = "12-345-6789";

echo isValidSSN($ssn1) ? "Valid" : "Invalid"; // Valid
echo isValidSSN($ssn2) ? "Valid" : "Invalid"; // Invalid

✅ সংক্ষেপে:

✅ প্রশ্ন ২৬: Using Laravel's Cache facade, optimize a scenario where API responses are cached for frequent requests but invalidated whenever the corresponding database table is updated.

Use PHP's Redis extension for caching.Implement a fallback for file-based caching if Redis isn't available.

যেখানে Laravel Cache Facade ব্যবহার করে API রেসপন্স ক্যাশ করা হয়েছে এবং ডাটাবেজ আপডেট হলেই ক্যাশ ইনভ্যালিড হচ্ছে। Redis ব্যবহার করা হয়েছে এবং Redis না থাকলে file-based fallback ও যুক্ত আছে।

✅ উত্তর:

✅ লক্ষ্য:

API রেসপন্স ক্যাশ করতে হবে
ক্যাশ তখনই ইনভ্যালিড হবে যখন ডাটাবেজ আপডেট হয়
Redis ব্যবহার করব, কিন্তু Redis না থাকলে file fallback হবে

🔧 ধাপ ১: .env ও cache.php ফাইল কনফিগার করুন

✅ .env ফাইলে যুক্ত করুন:

CACHE_DRIVER=redis
REDIS_CLIENT=phpredis

✅ config/cache.php

'default' => env('CACHE_DRIVER', 'file'), // Redis না থাকলে fallback 'file'

Laravel স্বয়ংক্রিয়ভাবে fallback cache ব্যবহার করে।

📦 ধাপ ২: Redis সেটআপ

Redis ইন্সটল করুন (উবুন্টু):

sudo apt install redis
sudo systemctl enable redis
sudo systemctl start redis

Laravel Redis প্যাকেজ আগে থেকেই অন্তর্ভুক্ত থাকে। তবে নিশ্চিত করতে পারেন:

composer require predis/predis

🔁 ধাপ ৩: API রেসপন্স ক্যাশ করুন

ধরি /api/products রাউট রয়েছে।

📁 ProductController.php

use Illuminate\Support\Facades\Cache;
use App\Models\Product;

public function index()
{
    $cacheKey = 'products.all';

    // Redis/File Cache থেকে রেসপন্স নেওয়া, না থাকলে DB থেকে
    $products = Cache::remember($cacheKey, 60, function () {
        return Product::all();
    });

    return response()->json($products);
}

🧹 ধাপ ৪: ক্যাশ ইনভ্যালিড করা যখন ডেটা আপডেট হয়

📁 ProductController.php

public function update(Request $request, $id)
{
    $product = Product::findOrFail($id);
    $product->update($request->all());

    // ক্যাশ ডিলিট
    Cache::forget('products.all');

    return response()->json(['message' => 'Product updated']);
}

এভাবে আপনি store() বা delete() মেথডেও Cache::forget() যোগ করতে পারেন।

🎯 Optional: Observer ব্যবহার করে অটো ক্যাশ ইনভ্যালিডেশন

📁 app/Observers/ProductObserver.php

namespace App\Observers;
use App\Models\Product;
use Illuminate\Support\Facades\Cache;

class ProductObserver
{
    public function saved(Product $product)
    {
        Cache::forget('products.all');
    }

    public function deleted(Product $product)
    {
        Cache::forget('products.all');
    }
}

📁 AppServiceProvider.php

use App\Models\Product;
use App\Observers\ProductObserver;

public function boot()
{
    Product::observe(ProductObserver::class);
}

🧪 Bonus: Cache fallback যাচাই

আপনি Redis সার্ভার বন্ধ করে file fallback কাজ করছে কিনা দেখুন:

sudo systemctl stop redis
php artisan route:clear
php artisan config:clear

রান করলে Laravel নিজেই fallback ড্রাইভারে (file) চলে যাবে।

✅ সারসংক্ষেপ:

❓ প্রশ্ন ২৭: তুমি একটি Laravel কোড পেয়েছো যা অনেক ধীরগতিতে চলছে। নিচের কোডটি কীভাবে অপটিমাইজ করবে যাতে ডাটাবেজ কোয়েরির সংখ্যা কমানো যায়?

$orders = Order::where('status', 'completed')->get();
foreach ($orders as $order) {
    $items = $order->items;
    foreach ($items as $item) {
        $details = $item->details;
    }
}

✅ উত্তর:

উপরের কোডটি N+1 Query Problem এর শিকার। প্রতিটি Order এর জন্য আলাদা করে items এবং প্রতিটি item এর জন্য আলাদা করে details কুয়্যারি চালানো হচ্ছে। এর ফলে অনেকগুলো অপ্রয়োজনীয় ডাটাবেজ হিট হয়।

🔧 সমাধান: Eager Loading ব্যবহার করুন

Laravel-এর with() মেথড ব্যবহার করে আমরা প্রয়োজনীয় রিলেশনগুলো একসাথে লোড করতে পারি।

✅ অপটিমাইজড কোড:

$orders = Order::with('items.details')
    ->where('status', 'completed')
    ->get();

foreach ($orders as $order) {
    foreach ($order->items as $item) {
        $details = $item->details;
    }
}

🧠 ব্যাখ্যা:

🔍 ফলাফল:

Performance বৃদ্ধি পাবে
Query সংখ্যা কমবে
Memory Efficient হবে
ডেটা একসাথে ক্যাশে থাকতে পারবে

✅ সংক্ষেপে:

✅ প্রশ্ন 28: . You are given the following PHP script, which processes a large array, Rewrite it to reduce memory usage without changing the output.

code:

$data = [];
for ($i = 0; $i < 100000; $i++) {
$data[] = str_repeat('X', 1000);
}
echo array_sum(array_map('strlen', $data));

✅ উত্তর:

নিশ্চয়ই! নিচে দেওয়া কোডটি একটি বড় অ্যারে $data তৈরি করে যেখানে ১ লাখ এলিমেন্ট আছে, প্রতিটিতে ১০০০ বারের 'X' থাকে। এরপর strlen() দিয়ে প্রতিটি স্ট্রিংয়ের দৈর্ঘ্য বের করে তাদের যোগফল প্রিন্ট করে।

🔴 মূল সমস্যা:

$data[] = str_repeat('X', 1000);

এভাবে ১ লাখ বড় স্ট্রিং মেমোরিতে রেখে দেয়, যা প্রচুর মেমোরি খরচ করে।

✅ লক্ষ্য:

একই আউটপুট
কিন্তু কম memory consumption

✅ অপটিমাইজড ভার্সন:

$totalLength = 0;

for ($i = 0; $i < 100000; $i++) {
    $totalLength += strlen(str_repeat('X', 1000));
}

echo $totalLength;

✅ ব্যাখ্যা:

আমরা পুরো অ্যারে $data মেমোরিতে জমাই না।
সরাসরি প্রতিটি স্ট্রিংয়ের strlen বের করে totalLength এ যোগ করি।
মেমোরিতে 1 লাখ স্ট্রিং না রেখে সরাসরি যোগফল করা হয়, ফলে Memory Usage অনেক কমে যায়।

🔍 আউটপুট:

100000000

কারণ 100000 * 1000 = 100,000,000 চরিত্র

✅ অতিরিক্ত টিপস:

Laravel বা PHP performance optimization-এর সময় "avoid keeping large arrays in memory" খুব গুরুত্বপূর্ণ বিষয়।
একই কৌশল আপনি CSV read, log process, বা large dataset গুলোর ক্ষেত্রেও ব্যবহার করতে পারেন — streaming বা on-the-fly processing।

✅ প্রশ্ন 29:. Write a raw PHP script to handle form submission with:

XSS protection for input fields.
CSRF token generation and validation.

✅ উত্তর:

অবশ্যই! নিচে একটি সম্পূর্ণ Raw PHP স্ক্রিপ্ট দেওয়া হলো যা একটি ফর্ম প্রসেস করে এবং তাতে:

✅ XSS Protection
✅ CSRF Token Generation & Validation

উভয় সিকিউরিটি ব্যবস্থা অন্তর্ভুক্ত করা হয়েছে।

✅ Step-by-Step Raw PHP Script
📁 form.php

<?php
session_start();

// ✅ CSRF Token Generate
if (empty($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}

// ✅ যদি POST সাবমিট হয়
if ($_SERVER['REQUEST_METHOD'] === 'POST') {

    // ✅ 1. CSRF Token Validate
    if (!isset($_POST['csrf_token']) || $_POST['csrf_token'] !== $_SESSION['csrf_token']) {
        die('CSRF token validation failed!');
    }

    // ✅ 2. XSS Protection — input sanitize
    $name = htmlspecialchars(trim($_POST['name'] ?? ''));
    $email = htmlspecialchars(trim($_POST['email'] ?? ''));

    echo "<h3>Form submitted safely!</h3>";
    echo "Name: " . $name . "<br>";
    echo "Email: " . $email . "<br>";

    // ✅ Optional: regenerate token for next form
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}
?>

<!-- ✅ HTML Form -->
<!DOCTYPE html>
<html>
<head><title>Secure Form</title></head>
<body>
    <h2>Secure Form</h2>
    <form method="POST" action="form.php">
        <label>Name:</label><br>
        <input type="text" name="name" required><br><br>

        <label>Email:</label><br>
        <input type="email" name="email" required><br><br>

        <!-- ✅ CSRF Token -->
        <input type="hidden" name="csrf_token" value="<?php echo $_SESSION['csrf_token']; ?>">

        <button type="submit">Submit</button>
    </form>
</body>
</html>

🔐 Breakdown

✅ Example Output:

Form submitted safely!
Name: Ruhul Amin
Email: ruhul@example.com

🛡️ Extra Security Tips:

XSS রোধে প্রতিটি আউটপুটেও htmlspecialchars() ব্যবহার করুন
CSRF Token প্রতিটি ফর্মে নতুন করে জেনারেট করা ভালো (per request)
আরও শক্তিশালী validation-এর জন্য filter_var() ব্যবহার করতে পারেন

✅ প্রশ্ন 30: Implement a custom artisan command to archive orders older than 1 year by:

Moving them to an archive table.Logging the operation details to a custom log file.Handling errors gracefully with retries and notifications.

✅ উত্তর:

অবশ্যই! নিচে Laravel Custom Artisan Command এর মাধ্যমে একটি সম্পূর্ণ সমাধান দেওয়া হলো যেখানে:

✅ ১ বছরের পুরোনো অর্ডারগুলো orders টেবিল থেকে archived_orders টেবিলে সরিয়ে নেওয়া হচ্ছে
✅ অপারেশন ডিটেইলস custom log file এ সংরক্ষণ করা হচ্ছে
✅ রিট্রাই ও নোটিফিকেশন সহ error handling ব্যবস্থাও রাখা হয়েছে

🛠️ ধাপ ১: archived_orders মাইগ্রেশন তৈরি করুন

php artisan make:migration create_archived_orders_table

📁 database/migrations/xxxx_xx_xx_create_archived_orders_table.php

public function up()
{
    Schema::create('archived_orders', function (Blueprint $table) {
        $table->id();
        $table->unsignedBigInteger('user_id');
        $table->decimal('amount', 10, 2);
        $table->timestamps();
    });
}

php artisan migrate

🧑‍💻 ধাপ ২: কাস্টম কমান্ড তৈরি করুন

php artisan make:command ArchiveOldOrders

📁 app/Console/Commands/ArchiveOldOrders.php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Throwable;

class ArchiveOldOrders extends Command
{
    protected $signature = 'orders:archive-old';
    protected $description = 'Archive orders older than 1 year to archived_orders table';

    public function handle()
    {
        $this->info('Starting archive process...');
        $attempts = 0;
        $maxAttempts = 3;

        do {
            try {
                DB::beginTransaction();

                $oldOrders = DB::table('orders')
                    ->where('created_at', '<', now()->subYear())
                    ->get();

                foreach ($oldOrders as $order) {
                    DB::table('archived_orders')->insert([
                        'id'        => $order->id,
                        'user_id'   => $order->user_id,
                        'amount'    => $order->amount,
                        'created_at'=> $order->created_at,
                        'updated_at'=> $order->updated_at,
                    ]);

                    DB::table('orders')->where('id', $order->id)->delete();

                    // ✅ কাস্টম লগ ফাইলে লগ করা
                    Log::channel('archive')->info("Archived order ID: {$order->id}");
                }

                DB::commit();
                $this->info('Archiving complete. Total orders: ' . count($oldOrders));
                return Command::SUCCESS;

            } catch (Throwable $e) {
                DB::rollBack();
                $attempts++;

                Log::channel('archive')->error("Attempt {$attempts} failed: " . $e->getMessage());

                if ($attempts >= $maxAttempts) {
                    $this->error('Archiving failed after 3 attempts.');
                    // ✅ Email or Slack notification if needed
                    // Notification::route('mail', 'admin@example.com')->notify(new ArchiveFailedNotification($e));
                    return Command::FAILURE;
                }

                $this->warn("Retrying... (Attempt: {$attempts})");
                sleep(2); // delay between retries
            }
        } while ($attempts < $maxAttempts);
    }
}

📝 ধাপ ৩: কাস্টম লগ চ্যানেল তৈরি করুন

📁 config/logging.php এ channels সেকশনে যুক্ত করুন:

'archive' => [
    'driver' => 'single',
    'path' => storage_path('logs/order-archive.log'),
    'level' => 'info',
],

🚀 ধাপ ৪: Artisan Command রান করুন

php artisan orders:archive-old

📄 লগ ফাইল

লগ পাবেন এখানে:

storage/logs/order-archive.log

উদাহরণ:

[2025-05-26 12:30:00] local.INFO: Archived order ID: 10123
[2025-05-26 12:30:00] local.INFO: Archived order ID: 10124

🔐 Bonus: নোটিফিকেশন ফেইল হলে

// Notification::route('mail', 'admin@example.com')
// ->notify(new ArchiveFailedNotification($e));

চাইলে আমি ArchiveFailedNotification ক্লাসও তৈরি করে দিতে পারি।

✅ সংক্ষেপে

React IQ (PHero)

Ruhul Amin Sujon — Tue, 29 Apr 2025 20:59:51 +0000

সাক্ষাৎকার প্রশ্নোত্তর (বাংলা অনুবাদ)
১. সাক্ষাৎকার প্রস্তুতি (Mock Interview Preparation)

প্রশ্ন: নিজের সম্পর্কে কিছু বলুন।
উত্তর: আমার নাম রুহুল আমিন সুজন এবং আমার বয়স ২৩ বছর। আমি ছয় মাস আগে সোনারগাঁও বিশ্ববিদ্যালয় থেকে কম্পিউটার সায়েন্স ও ইঞ্জিনিয়ারিং-এ বিএসসি ডিগ্রি অর্জন করেছি। আমার সিজিপিএ ৪.০০ এর মধ্যে ৩.৬। আমি ওয়েব ডেভেলপমেন্টে কাজ করতে ভালোবাসি এবং প্রতিদিন নতুন কিছু শেখার চেষ্টা করি। আমি প্রোগ্রামিং হিরো থেকে সফলভাবে MERN Stack কোর্স সম্পন্ন করেছি। আমি ওয়েব ডেভেলপার হিসেবে আমার কাজকে গুরুত্বের সাথে নেই, যার মানে এই যে, আমি সব সময় নিজেকে আপডেট রাখার চেষ্টা করি এই দ্রুত পরিবর্তনশীল ইন্ডাস্ট্রিতে। আমি সব সময় উদ্যমী এবং নতুন স্কিল শিখতে আগ্রহী।

প্রশ্ন: আপনার সেরা প্রজেক্ট কোনটি? এর প্রধান ফিচারগুলো কী? এটি করতে গিয়ে আপনি কী কী চ্যালেঞ্জ ফেস করেছেন?
উত্তর: আমার সেরা প্রজেক্ট হচ্ছে 'Parts Bazar'। এই প্রজেক্টে দুটি ড্যাশবোর্ড রয়েছে - একটি ইউজার ড্যাশবোর্ড এবং অপরটি অ্যাডমিন ড্যাশবোর্ড। ইউজাররা পণ্য কিনতে পারে এবং তাদের অর্ডার দেখতে পারে। তারা যেকোনো আন্তর্জাতিক ক্রেডিট কার্ড ব্যবহার করে পেমেন্ট করতে পারে। অ্যাডমিন সব ইউজার দেখতে পারে, নতুন অ্যাডমিন বানাতে পারে, পণ্য যোগ, আপডেট ও ডিলিট করতে পারে এবং সব অর্ডার ও পেমেন্ট স্ট্যাটাস দেখতে পারে। যেসব অর্ডার পেমেন্ট হয়নি, অ্যাডমিন তা ডিলিট করতে পারে। আমি JWT টোকেন নিয়ে সমস্যায় পড়েছিলাম। প্রথমে টোকেন তৈরি করতে পারছিলাম না এবং দুইদিন ধরে সমস্যাটা সমাধান করতে পারিনি। পরে টিউটোরিয়াল দেখি এবং ডকুমেন্টেশন পড়ে আমি সমস্যার সমাধান করি।

প্রশ্ন: আমরা কেন আপনাকে নিয়োগ দিব?
উত্তর: আমি মনে করি আমার ভালো একাডেমিক ব্যাকগ্রাউন্ড এবং যেসব স্কিল ও অভিজ্ঞতা আপনারা খুঁজছেন তা আমার মধ্যে রয়েছে। যদি আমি সুযোগ পাই, তবে আমি নিজের দক্ষতা তৈরি করার জন্য মনোযোগ দিয়ে কাজ করবো, যা আমার জন্য এবং আপনার প্রতিষ্ঠানের জন্য উপকারী হবে।
প্রশ্ন: আপনার স্যালারি প্রত্যাশা কত?
উত্তর: একজন ফ্রেশার হিসেবে আমার প্রথম অগ্রাধিকার হচ্ছে একটি চাকরি পাওয়া এবং ব্যবহারিকভাবে আমার জ্ঞান ও দক্ষতা উন্নত করা। আমি কোম্পানির নীতিমালা অনুযায়ী বেতন প্রত্যাশা করি এবং এতে আমি একমত।

প্রশ্ন: আমাদের জন্য আপনার কোনো প্রশ্ন আছে কি?
উত্তর: ১. আপনাদের অফিসে কি চা বা কফি পাওয়া যায়?
২. যদি আমি এই পজিশনের জন্য নির্বাচিত হই, তাহলে প্রথম দুই মাসে আপনি আমার কাছ থেকে কী প্রত্যাশা করবেন?
৩. এখন পর্যন্ত আমার পারফরম্যান্স বিবেচনায়, যদি আমি নির্বাচিত হই তাহলে কোন দিকগুলোতে উন্নতি করা উচিত? আর যদি না হই তাহলে ভবিষ্যতে সফল হওয়ার জন্য আপনি কী পরামর্শ দিবেন?

প্রশ্ন: আপনার দুর্বলতা কী?
উত্তর: রাতে দেরি করে ঘুমানো আমার একটি খারাপ অভ্যাস।

২. HTML

প্রশ্ন: HTML4 এবং HTML5 এর মধ্যে পার্থক্য কী?

উত্তর:
১. <audio>, <video>, <header>, <footer>, <canvas>, <article> ইত্যাদি ট্যাগ HTML5-এ সাপোর্ট করে, কিন্তু HTML4-এ এসব সাপোর্ট নেই।
২. HTML4-এ মাল্টিমিডিয়া সাপোর্টিং ট্যাগ নেই, কিন্তু HTML5 মাল্টিমিডিয়া কন্টেন্ট সাপোর্ট করে।
৩. HTML4 ক্লায়েন্ট-সাইড ডেটা সংরক্ষণে ক্যাশ ব্যবহার করলেও HTML5 web storage, web SQL, ও application cache ব্যবহার করে।
৪. HTML5 তে ভুল কোড হ্যান্ডলিং আরও ভালোভাবে করা যায়, HTML4 তে তেমন না।

প্রশ্ন: HTML-এ semantic ট্যাগ কী? কিছু উদাহরণ দিন।

উত্তর:
Semantic ট্যাগ এমন একটি ট্যাগ যা তার অর্থ স্পষ্ট করে, যেমন: <article>, <header>, <footer>, <nav>, <section>।
অপরদিকে

ও হলো non-semantic, কারণ এগুলো কনটেন্টের মানে প্রকাশ করে না।

প্রশ্ন: Article, div, section, nav, aside এর উদ্দেশ্য কী?

উত্তর:
সবগুলোই semantic ট্যাগ। এর মূল উদ্দেশ্য হলো পেজের কনটেন্টের গঠন বা অর্থ ব্রাউজার এবং ডেভেলপারদের জন্য স্পষ্ট করা।

প্রশ্ন: Meta tag কেন ব্যবহার করবেন?

উত্তর:
Meta tag HTML ডকুমেন্ট সম্পর্কে অতিরিক্ত তথ্য (metadata) সংরক্ষণ করে।
এটি সার্চ ইঞ্জিন, ব্রাউজার এবং অন্যান্য ওয়েব সার্ভিসের জন্য গুরুত্বপূর্ণ।
যেমন: ক্যারেক্টার সেট, কীওয়ার্ড, লেখক, এবং ভিউপোর্ট সেটিংস নির্ধারণ করা।

প্রশ্ন: inline, inline-block এবং block উপাদানের মধ্যে পার্থক্য কী?

উত্তর:

inline: height/width নির্ধারণ করা যায় না; কনটেন্ট অনুযায়ী সাইজ হয়।
inline-block: height/width নির্ধারণ করা যায় এবং এটি একটি লাইনে থাকে।
block: নতুন লাইনে শুরু হয়, পুরো প্রস্থ জুড়ে স্থান নেয়, height/width নির্ধারণ করা যায়।

প্রশ্ন: strong, b, bold, em, i - এদের মধ্যে পার্থক্য কী?

উত্তর:

<b> এবং <i> স্টাইলিং ট্যাগ – সরাসরি bold ও italic করে।
<strong> এবং <em> semantic ট্যাগ – গুরুত্বপূর্ণ বা জোর দিয়ে বোঝাতে ব্যবহৃত হয়, স্টাইল CSS দিয়ে নিয়ন্ত্রণযোগ্য।

প্রশ্ন: HTML-এ properties এবং attributes এর মধ্যে পার্থক্য কী?

উত্তর:

Attribute: HTML নির্ধারণ করে।
Property: DOM দ্বারা নির্ধারিত।
Attribute এর মান স্থির; Property এর মান পরিবর্তনশীল।

প্রশ্ন: Viewport কী?

উত্তর:
Viewport হচ্ছে ব্রাউজারে দৃশ্যমান ওয়েব পেজের এলাকা, যা ডিভাইস ভেদে ভিন্ন হতে পারে।

প্রশ্ন: Audio এবং Video tag কি ব্যবহার করেছেন? কীভাবে কাজ করে?

উত্তর:
হ্যাঁ, ব্যবহার করেছি। <audio> ও <video> ট্যাগের মাধ্যমে মিডিয়া যুক্ত করা যায়। src অ্যাট্রিবিউটে ফাইল সোর্স দিতে হয়, controls অ্যাট্রিবিউট ব্যবহার করলে ইউজার প্লে/পজ করতে পারে।

প্রশ্ন: Hyperlink কী? কোন ট্যাগ ও অ্যাট্রিবিউট ব্যবহার করবেন?

উত্তর:
হাইপারলিঙ্ক হলো একটি লিংক যা ক্লিক করলে ব্যবহারকারী অন্য পৃষ্ঠায় যেতে পারে।
ট্যাগ: <a>
অ্যাট্রিবিউট: href (লিংকের গন্তব্য নির্দেশ করে)।

প্রশ্ন: HTML elements এবং tags এর মধ্যে পার্থক্য কী?

উত্তর:

Tag: <p>, <div> ইত্যাদি, HTML এর গঠন।
Element: Tag সহ কনটেন্ট, যেমন <p>Text</p>।

প্রশ্ন: charset কী এবং কেন ব্যবহার করবেন?

উত্তর:
charset HTML ডকুমেন্টের ক্যারেক্টার এনকোডিং নির্ধারণ করে। সাধারণত UTF-8 ব্যবহার করা হয়, যা বিশ্বের প্রায় সব ভাষা সাপোর্ট করে।

প্রশ্ন: HTML5-এ image map কী?

উত্তর:
Image map হলো একটি ছবি যেখানে নির্দিষ্ট কিছু অংশে ক্লিক করে ভিন্ন লিংকে যাওয়া যায়।
ট্যাগ: <map> এবং <area>

৩. CSS

প্রশ্ন: Flex layout কী? Flex এবং Grid layout এর মধ্যে পার্থক্য কী?

উত্তর:
Flex Layout একটি উন্নততর লেআউট মেথড যা এলিমেন্টগুলোকে স্মার্টলি সারি বা কলামে সাজাতে সাহায্য করে।

Flexbox একমাত্রিক (row বা column)।
Grid হলো দ্বিমাত্রিক (row ও column একসাথে)।
Grid ব্যবহার করলে আরও জটিল এবং নিখুঁত লেআউট ডিজাইন করা যায়।

প্রশ্ন: CSS position property ব্যাখ্যা করুন। Absolute ও relative position এর মধ্যে পার্থক্য কী?

উত্তর:
CSS Position property দ্বারা একটি এলিমেন্টকে কোথায় অবস্থান করবে তা নির্ধারণ করা হয়।

relative: তার স্বাভাবিক অবস্থান থেকে সরানো হয়।
absolute: নিকটবর্তী positioned parent এর উপর ভিত্তি করে নির্ধারিত হয়।

প্রশ্ন: Box model কী? এর উপাদানগুলো কী কী?

উত্তর:
Box model HTML এর প্রতিটি এলিমেন্টকে একটি বক্স হিসেবে ধরে। এর উপাদান:
১. Content
২. Padding
৩. Border
৪. Margin

প্রশ্ন: Hover effect কী? Active class-এর উদ্দেশ্য কী? বা Pseudo-class কী?

উত্তর:

Hover Effect: ইউজার মাউস নিয়ে গেলে যেকোনো CSS পরিবর্তন যেমন কালার বা সাইজ হওয়া।
Active class: যখন ইউজার কোনো এলিমেন্টে ক্লিক করে তখন সেটির স্টাইল পরিবর্তন হয়।
Pseudo-class: একটি class যা এলিমেন্টের নির্দিষ্ট স্টেটে স্টাইল নির্ধারণ করে। যেমন: :hover, :active, :focus

প্রশ্ন: CSS-এর বিভিন্ন selector কী কী? Class এবং ID selector এর পার্থক্য?

উত্তর:
Selector এর প্রকারভেদ:

Element selector
Class selector (.class-name)
ID selector (#id-name)
Universal selector (*)
Group selector (h1, p) Class vs ID: একটি ক্লাস বহুবার ব্যবহার করা যায়, কিন্তু ID একবারই ব্যবহারযোগ্য।

প্রশ্ন: CSS Specificity কী?

উত্তর:
Specificity হলো কোন CSS নিয়ম আগে প্রাধান্য পাবে তা নির্ধারণ করার নিয়ম। বেশি নির্দিষ্ট সিলেক্টর হলে তা কম নির্দিষ্ট সিলেক্টরের উপর প্রাধান্য পায়।

প্রশ্ন: CSS Preprocessor কী? Sass এর সুবিধা কী?

উত্তর:
CSS Preprocessor একটি টুল যা CSS থেকে আরও উন্নত ফিচার যোগ করে।
Sass এর সুবিধা:

কোড পুনঃব্যবহারযোগ্য হয় (variables, mixins)
CSS লেখার সময় কম লাগে
Nested rules সহজ করে

প্রশ্ন: Pseudo element কী? একটি উদাহরণ দিন।

উত্তর:
Pseudo element ব্যবহার করে একটি এলিমেন্টের নির্দিষ্ট অংশে স্টাইল প্রয়োগ করা যায়।
উদাহরণ:

::first-line
::before, ::after

প্রশ্ন: Media query ব্যবহার করে একটি ওয়েবসাইট কিভাবে responsive করবেন?

উত্তর:
Media query CSS3 এর একটি ফিচার। এটি দিয়ে বিভিন্ন স্ক্রিন সাইজ অনুযায়ী স্টাইল অ্যাডজাস্ট করা যায়। উদাহরণ:

@media (max-width: 600px) {
  body {
    font-size: 14px;
  }
}

প্রশ্ন: কিভাবে font size responsive করবেন? CSS এর কোন units ব্যবহার করবেন?

উত্তর:

vw (viewport width), em, rem ব্যবহার করে ফন্ট সাইজ responsive করা যায়।
Media query দিয়ে ভিন্ন স্ক্রিন সাইজে আলাদা সাইজ সেট করা যায়।

প্রশ্ন: Transition এবং Transform এর মধ্যে পার্থক্য কী?

উত্তর:

Transform: কোনো এলিমেন্টের রূপ পরিবর্তন করে (ঘোরানো, স্কেল করা)।
Transition: এক অবস্থা থেকে আরেক অবস্থায় ধীরে ধীরে পরিবর্তন ঘটায়।

প্রশ্ন: কিভাবে একটি div-কে আরেকটি div-এর মধ্যে উভয় দিক থেকে কেন্দ্রস্থ করবেন?

উত্তর:

.parent {
  display: flex;
  justify-content: center;
  align-items: center;
}

৪. JavaScript (JS)

প্রশ্ন: JavaScript কীভাবে কাজ করে? Event loop কী?

উত্তর:
JavaScript একটি single-threaded ভাষা হলেও এটি asynchronous কাজ করতে পারে Event Loop এর মাধ্যমে। ব্রাউজার JavaScript কোড ইন্টারপ্রেট করে এবং চলমান রাখে।
Event Loop ব্রাউজারের task queue থেকে একের পর এক কাজ নিয়ে execute করে।

প্রশ্ন: JavaScript কোড কীভাবে ব্রাউজারে execute হয়?

উত্তর:
JavaScript কোড ব্রাউজারে লোড হওয়ার পর, ব্রাউজারের ইঞ্জিন (যেমন Chrome-এর V8) কোডটি লাইনে লাইনে পড়ে এবং ইনস্ট্যান্টলি execute করে।

প্রশ্ন: “==” এবং “===” এর মধ্যে পার্থক্য কী?

উত্তর:

==: কেবলমাত্র value চেক করে।
===: value এবং type দুটোই চেক করে (strict equality)।

প্রশ্ন: Callback function কী?

উত্তর:
Callback function হলো একটি ফাংশন যা অন্য একটি ফাংশনের আর্গুমেন্ট হিসেবে পাঠানো হয় এবং পরে কল করা হয়।

প্রশ্ন: কখন function থেকে return করবেন? কিভাবে একাধিক value return করবেন?

উত্তর:
কোনো function থেকে result চাইলে return ব্যবহার করতে হয়।
JS একাধিক value return করতে পারে না সরাসরি। তাই array বা object আকারে value return করতে হয়।

প্রশ্ন: bind, call এবং apply এর কাজ কী?

উত্তর:

call() ও apply() সরাসরি ফাংশন এক্সিকিউট করে;
bind() নতুন ফাংশন রিটার্ন করে যেটি পরে কল করা যায়।
পার্থক্য: call(arg1, arg2), apply([arg1, arg2]), bind(arg1, arg2)

প্রশ্ন: Closure কীভাবে কাজ করে?

উত্তর:
Closure হলো এমন একটি ফাংশন যা তার parent function-এর scope থেকে ভেরিয়েবল access করতে পারে, এমনকি parent ফাংশন execute শেষ হয়ে গেলেও।

প্রশ্ন: JavaScript এ “this” কী বোঝায়?

উত্তর:

Regular function-এ this হলো global object (যেমন window)।
Object method-এ this হলো সেই object।
arrow function এ this parent scope থেকে আসে।

প্রশ্ন: Event bubbling কী? Delegation কীভাবে কাজ করে?

উত্তর:
Event bubbling মানে হলো একটি event DOM এর নিচ থেকে উপরের দিকে propagate হয়। Event Delegation মানে হলো parent এলিমেন্টে ইভেন্ট add করা, যাতে child-এর ইভেন্টও handle হয়।

প্রশ্ন: Hoisting কী?

উত্তর:
Hoisting মানে ভ্যারিয়েবল বা ফাংশন ডিক্লেয়ারেশন উপরের দিকে উঠে যায়। যেমন:

console.log(a); // undefined
var a = 10;

প্রশ্ন: Recursive function কী?

উত্তর:
যে ফাংশন নিজেই নিজেকে কল করে, তাকে recursive function বলে।

প্রশ্ন: undefined ও null এর পার্থক্য কী?

উত্তর:

undefined: ভ্যারিয়েবল ডিক্লেয়ার করা হয়েছে কিন্তু মান অ্যাসাইন করা হয়নি।
null: ইচ্ছাকৃতভাবে "খালি" ভ্যালু সেট করা।

প্রশ্ন: JavaScript এর data types কী কী?

উত্তর:

Primitive: string, number, boolean, null, undefined, symbol, bigint
Non-primitive: array, object, function

প্রশ্ন: DOM কী?

উত্তর:
DOM (Document Object Model) হলো একটি API যা HTML ডকুমেন্টকে গঠন করে এবং স্ক্রিপ্ট দিয়ে তা manipulate করা যায়।

প্রশ্ন: JavaScript static type না dynamic type?

উত্তর:
JavaScript হলো dynamically typed language। এক ভ্যারিয়েবল ভিন্ন ভিন্ন টাইপ ধারণ করতে পারে।

৫. ES6

প্রশ্ন: ES6 কী?

উত্তর:
ES6 (ECMAScript 2015) হলো JavaScript-এর একটি আধুনিক সংস্করণ, যা নতুন সিনট্যাক্স ও ফিচার নিয়ে এসেছে — যেমন:

arrow function
template literals
destructuring
class
modules ইত্যাদি এইসব ফিচার কোডকে আরও পরিষ্কার, সংক্ষিপ্ত এবং রিডেবল করে তোলে।

প্রশ্ন: var, let এবং const এর মধ্যে পার্থক্য কী?

উত্তর:

প্রশ্ন: Default parameters কেন ব্যবহার করবেন?

উত্তর:
Function call করার সময় যদি কোনো প্যারামিটার না পাঠানো হয়, তাহলে default মান ব্যবহার করার জন্য default parameter ব্যবহৃত হয়।

function greet(name = "Guest") {
  console.log("Hello " + name);
}

প্রশ্ন: Spread operator কীভাবে কাজ করে?

উত্তর:
Spread operator (...) array বা object কে কপি বা merge করতে ব্যবহৃত হয়।

const nums = [1, 2, 3];  
const newNums = [...nums, 4]; // [1, 2, 3, 4]

প্রশ্ন: Class এবং Object এর মধ্যে পার্থক্য কী?

উত্তর:

Class হলো object তৈরির ব্লুপ্রিন্ট বা খসড়া।
Object হলো class-এর instance।
class তৈরি করলে মেমোরি বরাদ্দ হয় না, কিন্তু object তৈরি করলে হয়।

প্রশ্ন: Prototype chain কী? Inheritance কিভাবে কাজ করে?

উত্তর:
JavaScript এ প্রতিটি object-এর মধ্যে একটি internal property থাকে যাকে prototype বলে।
Prototype এর মাধ্যমে এক object অন্য object-এর প্রপার্টি ও মেথড অ্যাক্সেস করতে পারে। এটাকেই Prototype Chain বলা হয়।

প্রশ্ন: Call by value এবং Call by reference এর মধ্যে পার্থক্য কী?

উত্তর:

Call by value:
প্রিমিটিভ ডেটা টাইপ — ফাংশনে পাঠানোর সময় আসল ভ্যালু কপি হয়ে যায়। পরিবর্তন আসল ভ্যারিয়েবলকে প্রভাবিত করে না।
Call by reference:
অবজেক্ট টাইপ — ফাংশনে পাঠালে মূল ভ্যারিয়েবলের রেফারেন্স পাঠানো হয়। তাই ফাংশনের ভেতরে পরিবর্তন করলে সেটি বাইরেও প্রভাব ফেলে।

প্রশ্ন: Scope কী?

উত্তর:
Scope হলো কোন ভ্যারিয়েবল কোথা থেকে অ্যাক্সেস করা যাবে তার সীমা।

Global Scope: ব্লকের বাইরে ঘোষণা করা ভ্যারিয়েবল।
Local Scope: ব্লকের ভিতরে ঘোষণা করা ভ্যারিয়েবল।
Block Scope: let বা const দিয়ে ব্লকের ভিতরে তৈরি করা ভ্যারিয়েবল।

প্রশ্ন: Higher-order function কী?

উত্তর:
যে function অন্য function কে argument হিসেবে নেয় বা return করে, তাকে higher-order function বলে।
উদাহরণ: map(), filter(), forEach()

প্রশ্ন: API কী? GET ও POST এর মধ্যে পার্থক্য কী?

উত্তর:
API (Application Programming Interface) হলো সফটওয়্যারের মাঝে যোগাযোগের মাধ্যম।

GET: ডেটা রিকোয়েস্ট করে।
POST: নতুন ডেটা সাবমিট করে (body-তে)। GET ইউআরএল-এ ডেটা পাঠায়; POST body-তে।

প্রশ্ন: LocalStorage এবং SessionStorage এর মধ্যে পার্থক্য কী?

উত্তর:

LocalStorage: ব্রাউজারে ডেটা চিরস্থায়ীভাবে সংরক্ষণ করে, ম্যানুয়ালি না মুছলে থাকে।
SessionStorage: শুধু একটি session পর্যন্ত ডেটা রাখে, ট্যাব বন্ধ করলে মুছে যায়।

প্রশ্ন: Cookies কী এবং কেন ব্যবহার করবেন?

উত্তর:
Cookies হলো ছোট টেক্সট ফাইল যা ইউজারের ব্রাউজারে সংরক্ষিত থাকে।
এটি ইউজারকে সনাক্ত করতে এবং ব্রাউজিং অভিজ্ঞতা উন্নত করতে ব্যবহৃত হয়।

প্রশ্ন: OOP (Object-Oriented Programming) কী?

উত্তর:
OOP হলো একটি প্রোগ্রামিং পদ্ধতি যেখানে সবকিছু object হিসেবে ব্যবহৃত হয়। এর চারটি মূল ধারণা হলো:
১. Encapsulation
২. Abstraction
৩. Inheritance
৪. Polymorphism

প্রশ্ন: Array এবং LinkedList এর মধ্যে পার্থক্য কী?

উত্তর:

Array: contiguous memory, fixed size, দ্রুত অ্যাক্সেস
LinkedList: non-contiguous memory, dynamic size, insert/delete সহজ

প্রশ্ন: JavaScript অ্যাপ্লিকেশন কীভাবে debug করবেন?

উত্তর:
Error message গুগলে সার্চ করুন। StackOverflow বা documentation পড়ে সমস্যার সমাধান খুঁজে বের করে কোডে প্রয়োগ করুন।

৬. React

প্রশ্ন: ReactJS কী? এর সুবিধা ও অসুবিধাগুলো কী?

উত্তর:

ReactJS হলো একটি জনপ্রিয় ফ্রন্টএন্ড JavaScript লাইব্রেরি যা UI (User Interface) তৈরি করতে ব্যবহৃত হয়। এটি Meta (Facebook) দ্বারা তৈরি ও পরিচালিত।

সুবিধা:

শেখা সহজ
ডাইনামিক ওয়েব অ্যাপ তৈরি সহজ
Component পুনঃব্যবহারযোগ্য
Performance উন্নত
JavaScript লাইব্রেরির সুবিধা
সহজে টেস্টিং করা যায়

অসুবিধা:

দ্রুত আপডেট হওয়ায় শেখা কঠিন হতে পারে
ডকুমেন্টেশন দুর্বল
শুধুমাত্র view নিয়ে কাজ করে
JSX নতুনদের জন্য জটিল হতে পারে

প্রশ্ন: আপনি কেন ReactJS ব্যবহার করবেন?

উত্তর:

ReactJS কোড সহজ, পরিচালনাযোগ্য ও পুনঃব্যবহারযোগ্য। এটি স্কেলেবল এবং দ্রুত অ্যাপ্লিকেশন তৈরিতে সহায়ক। পাশাপাশি অন্যান্য ফ্রেমওয়ার্কের তুলনায় ReactJS বেশি ফ্লেক্সিবল।

প্রশ্ন: Virtual DOM কী? Virtual এবং Real DOM এর মধ্যে পার্থক্য কী?

উত্তর:

Virtual DOM হলো DOM এর একটি হালকা ভার্সন যা মেমোরিতে থাকে এবং আসল DOM পরিবর্তনের আগে পার্থক্য চিহ্নিত করে।

পার্থক্য:

Real DOM সরাসরি UI পরিবর্তন করে, ধীরগতি।
Virtual DOM পরিবর্তন দ্রুত হয় এবং তারপর আসল DOM-এ প্রয়োগ হয়।

প্রশ্ন: Props ও State এর মধ্যে পার্থক্য কী?

উত্তর:

প্রশ্ন: useState কী এবং কেন ব্যবহার করেন?

উত্তর:

useState হলো React Hook যা ফাংশনাল কম্পোনেন্টে state ব্যবহারের সুবিধা দেয়। এতে component rerender হয় ডেটা চেঞ্জ হলে।

প্রশ্ন: Context API কী? Prop drilling এ এটি কীভাবে সাহায্য করে?

উত্তর:

Context API অনেকগুলো লেয়ারে ডেটা প্রপস না পাঠিয়ে সরাসরি component-এ পাঠানোর ব্যবস্থা করে। এটি prop drilling এর বিকল্প।

প্রশ্ন: useEffect ও useState এর মধ্যে পার্থক্য কী?

উত্তর:

useState: state পরিচালনা করে
useEffect: side-effect পরিচালনা করে (API call, timer, etc.) useEffect এর dependency array দিয়ে নির্ধারণ করা যায় কবে এটি চলবে।

প্রশ্ন: JSX কীভাবে কাজ করে?

উত্তর:

JSX মানে JavaScript XML — এটি HTML এর মত দেখতে হলেও JavaScript এর ভিতরেই লেখা হয়। Babel JSX কে JavaScript এ রূপান্তর করে।

প্রশ্ন: React Component Lifecycle ব্যাখ্যা করুন।

উত্তর:

React Component Lifecycle এর তিনটি ধাপ:

Mount: Component তৈরি ও DOM-এ যোগ হয় (constructor, render, componentDidMount)
Update: State/Props পরিবর্তন হলে ঘটে (render, componentDidUpdate)
Unmount: Component DOM থেকে মুছে যায় (componentWillUnmount)

প্রশ্ন: Custom Hook কী? কিভাবে তৈরি করবেন?

উত্তর:

Custom Hook হলো আপনার নিজের তৈরি React Hook যা সাধারণ লজিক অনেক Component-এ ব্যবহারের সুবিধা দেয়।

function useCustomHook() {
  const [data, setData] = useState(null);
  return [data, setData];
}

প্রশ্ন: আপনি কীভাবে একটি React অ্যাপ অপ্টিমাইজ করবেন?

উত্তর:

Component memoization (React.memo)
Lazy loading / Code splitting
useCallback ও useMemo ব্যবহার
উপযুক্ত key ব্যবহার
DOM update সীমিত রাখা
থ্রটল ও ডিবাউন্স ব্যবহার

প্রশ্ন: One-way ও Two-way data binding এর মধ্যে পার্থক্য কী? React কী ব্যবহার করে?

উত্তর:

React one-way data binding ব্যবহার করে। মানে প্যারেন্ট থেকে চাইল্ডে ডেটা যায়, কিন্তু চাইল্ড পরিবর্তন করলে তা প্যারেন্টে সরাসরি যাবে না।

প্রশ্ন: useEffect হুক থেকে কিছু return করলে কেন?

উত্তর:

useEffect থেকে return করা ফাংশনটি Cleanup ফাংশন হিসেবে কাজ করে — Component Unmount হলে বা dependency পরিবর্তনে এটি চলে।

৭. React IQ (ইন্টারভিউ প্রশ্নোত্তর)

প্রশ্ন: কিভাবে একটি Child Component থেকে Parent Component-এ ডেটা পাঠাবেন?

উত্তর:

১. প্রথমে parent ও child কম্পোনেন্ট তৈরি করুন।
২. parent কম্পোনেন্টে একটি function তৈরি করুন।
৩. এই function-টি prop হিসেবে child এ পাঠান।
৪. child থেকে button ক্লিক বা event এর মাধ্যমে সেই ফাংশন কল করে parent-এ ডেটা পাঠান।
৫. parent এ useState হুক ব্যবহার করে ডেটা সংরক্ষণ করুন।

প্রশ্ন: ৪টি বা তার বেশি props কীভাবে চাইল্ড কম্পোনেন্টে পাঠানো ভালো?

উত্তর:

Context API
Redux এই দুটি ব্যবহার করলে অনেক লেয়ার ডেটা না পাঠিয়ে centrally manage করা যায়।

প্রশ্ন: Redux কী এবং এর উদ্দেশ্য কী?

উত্তর:

Redux হলো একটি JavaScript state management লাইব্রেরি। এটি বড় অ্যাপ্লিকেশনের state (ডেটা) পরিচালনা সহজ করে এবং ডেটা flow নির্ভরযোগ্য রাখে। সাধারণত React এর সাথে ব্যবহার করা হয়।

প্রশ্ন: React Native কী? এটি সম্পর্কে আপনি কী জানেন?

উত্তর:

React Native হলো একটি ওপেন সোর্স ফ্রেমওয়ার্ক যা React ব্যবহার করে Android ও iOS অ্যাপ তৈরি করতে ব্যবহৃত হয়। এটি JavaScript ব্যবহার করে native mobile অ্যাপ তৈরি করে।

প্রশ্ন: Higher-order components (HOC) কী? একটি উদাহরণ দিন।

উত্তর:

HOC হলো এমন একটি ফাংশন যা একটি কম্পোনেন্ট নেয় এবং একটি নতুন কম্পোনেন্ট রিটার্ন করে।
উদাহরণ: withAuth(Component)

প্রশ্ন: useEffect হুক থেকে return কেন করা হয়?

উত্তর:

যখন একটি কম্পোনেন্ট unmount হয় তখন clean up করার জন্য useEffect থেকে return ফাংশন করা হয়।

প্রশ্ন: আপনি কীভাবে একটি React অ্যাপ অপ্টিমাইজ করবেন?

উত্তর:

১. Immutable ডেটা ব্যবহার
২. Functional Component ব্যবহার
৩. Code Split করে ছোট ছোট chunk তৈরি
৪. Inline function পরিহার
৫. Debounce ও Throttle
৬. Array map-এ index এর পরিবর্তে unique key ব্যবহার

প্রশ্ন: React অ্যাপে state ম্যানেজ করার বিভিন্ন উপায় কী?

উত্তর:

React অ্যাপে state management এর চারটি ধরন আছে:
১. Local state (useState)
২. Global state (Redux, Context API)
৩. Server state (React Query)
৪. URL state (React Router)

প্রশ্ন: useEffect হুক-এ dependency inject কেন করা হয়?

উত্তর:

Dependency array দিয়ে নির্ধারণ করা হয় useEffect কখন চলবে। যদি dependency না দেওয়া হয়, তাহলে প্রতিবার রেন্ডার হলে effect চলবে।

প্রশ্ন: আপনি কিভাবে React অ্যাপে re-render প্রতিরোধ করবেন?

উত্তর:

React.memo() ব্যবহার করে ফাংশনাল কম্পোনেন্ট memoize করা যায়
useMemo, useCallback হুক
কম্পোনেন্টকে যত সম্ভব ছোট ও নির্দিষ্ট রাখা

প্রশ্ন: ReactJS এর কিছু অসুবিধা বলুন।

উত্তর:

দ্রুত পরিবর্তনের কারণে নতুনদের জন্য শেখা কঠিন
ডকুমেন্টেশন দুর্বল
শুধুমাত্র View লেয়ার নিয়ে কাজ করে
JSX নতুনদের জন্য বিভ্রান্তিকর হতে পারে

প্রশ্ন: React কি One-way না Two-way Data Binding করে?

উত্তর:

React শুধুমাত্র One-way data binding করে — ডেটা প্যারেন্ট থেকে চাইল্ডে যায়।

প্রশ্ন: useEffect হুক থেকে কিছু return করলে কেন?

উত্তর:

এই return করা ফাংশন clean-up effect হিসেবে কাজ করে, যা কম্পোনেন্ট unmount হওয়ার সময় চলে।

৮. Node.js ও MongoDB

প্রশ্ন: Node.js কী?

উত্তর:

Node.js হলো একটি JavaScript runtime environment যা V8 engine ব্যবহার করে এবং ব্রাউজারের বাইরে JavaScript কোড চালাতে পারে।

প্রশ্ন: Node.js ও JavaScript এর মধ্যে পার্থক্য কী?

উত্তর:

JavaScript হলো প্রোগ্রামিং ল্যাঙ্গুয়েজ; Node.js হলো JS এর runtime environment।
JavaScript সাধারণত client-side এ চলে; Node.js server-side এ চলে।
Node.js ব্রাউজার ছাড়াও JS কোড চালাতে সক্ষম।

প্রশ্ন: Node.js কি single-threaded না multi-threaded?

উত্তর:

Node.js হলো single-threaded। তবে এটি asynchronous ও non-blocking architecture ব্যবহার করে।

প্রশ্ন: Node.js কি blocking না non-blocking কাজ করে?

উত্তর:
Node.js non-blocking ও asynchronous কাজ করে। এটি ইভেন্ট-চালিত (event-driven), তাই একাধিক অনুরোধ একসাথে পরিচালনা করতে পারে।

প্রশ্ন: NPM কী?

উত্তর:
NPM (Node Package Manager) হলো একটি টুল যেটি Node.js প্যাকেজ install, update, এবং manage করতে ব্যবহৃত হয়।

প্রশ্ন: ডাটাবেজের উদ্দেশ্য কী?

উত্তর:

ডাটাবেজ হলো তথ্য সংরক্ষণের একটি ব্যবস্থা। এর উদ্দেশ্য হলো তথ্যকে সংগঠিতভাবে সংরক্ষণ, ব্যবস্থাপনা ও দ্রুত অ্যাক্সেস নিশ্চিত করা।

প্রশ্ন: SQL ও NoSQL ডাটাবেজের মধ্যে পার্থক্য কী?

উত্তর:

প্রশ্ন: React এর সাথে Node ও MongoDB কেন ব্যবহৃত হয়? MySQL কেন নয়?

উত্তর:

MongoDB একটি NoSQL ডাটাবেজ, এটি document ভিত্তিক এবং ফ্লেক্সিবল। React ও Node JS এর সাথে এটি সহজেই মেলে।
MySQL schema নির্ভর এবং structure কঠিন, তাই MERN Stack এ MongoDB ব্যবহৃত হয়।

প্রশ্ন: Database design ও Database schema design বলতে কী বোঝায়?

উত্তর:

Database Design: ডাটাবেজের গঠন ও কাঠামো কেমন হবে তা পরিকল্পনা করা।
Schema Design: ডাটার গঠন এবং টেবিল বা ডকুমেন্ট কিভাবে সম্পর্কিত হবে তার নির্দেশনা।

প্রশ্ন: সার্ভার ক্র্যাশ করলে কী করবেন?

উত্তর:

১. সমস্যার লক্ষণ পর্যবেক্ষণ করুন
২. লোগস ও এরর চেক করুন
৩. Safe Mode-এ বুট করুন
৪. ইভেন্ট ভিউয়ার বা লিনাক্সের লগ ব্যবহার করুন
৫. সার্ভার রিস্টার্ট করুন
৬. ভবিষ্যতে এড়াতে মনিটরিং টুল ব্যবহার করুন

প্রশ্ন: API কিভাবে কাজ করে?

উত্তর:
API (Application Programming Interface) হলো সফটওয়্যারের মধ্যে যোগাযোগের মাধ্যম। এটি client এর অনুরোধ server এ পৌঁছে দেয় এবং উত্তরের ডেটা আবার client এ পাঠায়।

প্রশ্ন: CRUD কী?

উত্তর:

CRUD এর পূর্ণরূপ: Create, Read, Update, Delete — এটি ডাটাবেজ পরিচালনার মৌলিক চারটি কাজ।

প্রশ্ন: GET এবং POST এর মধ্যে পার্থক্য কী?

উত্তর:

GET: ইউআরএল এর মাধ্যমে ডেটা পাঠায়, সাধারণত ডেটা পড়ার জন্য।
POST: body এর মাধ্যমে ডেটা পাঠায়, সাধারণত নতুন ডেটা তৈরি বা সাবমিট করার জন্য।

প্রশ্ন: PUT ও PATCH এর মধ্যে পার্থক্য কী?

উত্তর:

PUT: সম্পূর্ণ রেকর্ড আপডেট করে বা নতুন রেকর্ড তৈরি করে।
PATCH: নির্দিষ্ট অংশ পরিবর্তন করে, সম্পূর্ণ রেকর্ড নয়।

প্রশ্ন: API সিকিউর করার উপায় কী?

উত্তর:

১. HTTPS ব্যবহার করুন
২. Token ভিত্তিক authentication (যেমন: JWT)
৩. Input validation করুন
৪. API rate limit করুন
৫. তথ্য URL এ না পাঠিয়ে body তে পাঠান
৬. OAuth ব্যবহার করুন

প্রশ্ন: Mongoose কী? এটি কিভাবে কাজ করে? আপনি কি এটি ব্যবহার করেছেন?

উত্তর:

Mongoose হলো MongoDB এর জন্য একটি ODM (Object Data Modeling) লাইব্রেরি যা schema validation, relationship এবং query পরিচালনা সহজ করে।
হ্যাঁ, আমি এটি ব্যবহার করেছি।

প্রশ্ন: Webpack কী?

উত্তর:
Webpack হলো একটি module bundler, যা একাধিক ফাইল/মডিউলকে একত্র করে একটি বা কিছু ফাইলে পরিণত করে।

প্রশ্ন: REST API কী?

উত্তর:

REST API হলো Representational State Transfer নীতিমালা অনুযায়ী তৈরি একটি API। এটি HTTP Method (GET, POST, PUT, DELETE) ব্যবহার করে ক্লায়েন্ট ও সার্ভারের মধ্যে ডেটা আদান-প্রদান করে।

Database - Level 1 - Part 1

Ruhul Amin Sujon — Thu, 24 Apr 2025 16:09:47 +0000

🔸 SQL সম্পর্কিত প্রশ্ন ও উত্তরঃ

প্রশ্ন ১: SQL কী?

উত্তর:

SQL (Structured Query Language) হলো একটি স্ট্যান্ডার্ড ল্যাঙ্গুয়েজ যা ডেটাবেইসে ডেটা insert, update, delete এবং query করার জন্য ব্যবহৃত হয়।

প্রশ্ন ২: SELECT, INSERT, UPDATE ও DELETE এর কাজ কী?

উত্তর:

SELECT – ডেটাবেইস থেকে ডেটা পড়তে ব্যবহৃত হয়
INSERT – নতুন ডেটা যোগ করতে ব্যবহৃত হয়
UPDATE – বিদ্যমান ডেটা আপডেট করতে ব্যবহৃত হয়
DELETE – ডেটা মুছে ফেলতে ব্যবহৃত হয়

প্রশ্ন ৩: WHERE এবং HAVING এর মধ্যে পার্থক্য কী?

উত্তর:

WHERE ব্যবহার হয় row ফিল্টার করার জন্য এবং এটি GROUP BY এর আগে ব্যবহৃত হয়।
HAVING ব্যবহার হয় aggregate result (যেমন COUNT(), SUM()) ফিল্টার করতে এবং এটি GROUP BY এর পরে ব্যবহৃত হয়।

প্রশ্ন ৪: GROUP BY কী কাজে লাগে?

উত্তর:

GROUP BY ব্যবহৃত হয় এক বা একাধিক কলামের উপর ভিত্তি করে ডেটা গ্রুপ করতে, সাধারণত aggregate function এর সাথে।

প্রশ্ন ৫: Index কী এবং কেন ব্যবহৃত হয়?

উত্তর:

Index হলো ডেটাবেইসের একটি ডেটা স্ট্রাকচার যা দ্রুত সার্চ ও রিট্রাইভাল সুবিধা দেয়। এটি query execution দ্রুত করতে সাহায্য করে।

🔸 ডেটাবেইস ডিজাইন ও কনসেপ্ট প্রশ্নঃ

প্রশ্ন ৬: Normalization কী?

উত্তর:

Normalization হলো একটি প্রক্রিয়া যা ডেটাবেইসকে redundancy (একই ডেটা বারবার রাখা) কমিয়ে এবং ডেটা integrity বাড়িয়ে অপ্টিমাইজ করে।

প্রশ্ন ৭: 1NF, 2NF, 3NF কী?

উত্তর:

1NF: প্রতিটি সেল এ্যাটমিক ভ্যালু রাখে
2NF: 1NF + সম্পূর্ণ primary key নির্ভরশীলতা
3NF: 2NF + ট্রানজিটিভ নির্ভরশীলতা দূর করা

প্রশ্ন ৮: Primary Key এবং Unique Key এর পার্থক্য কী?

উত্তর:

Primary Key – প্রতিটি row কে ইউনিকভাবে শনাক্ত করে, null থাকতে পারে না
Unique Key – ইউনিক মান রাখতে পারে, তবে একবার null থাকতে পারে

প্রশ্ন ৯: Foreign Key কী?

উত্তর:

একটি টেবিলের কলাম যা অন্য টেবিলের Primary Key কে রেফার করে, এটাকে Foreign Key বলে।

প্রশ্ন ১০: ACID মানে কী কী এবং এটি কেন ব্যবহার করা হয়? উদাহরণ সহ ব্যাখ্যা করো?

উত্তর:

🔸 ACID কী?

ACID হলো ডেটাবেইসে ট্রানজ্যাকশন ব্যবস্থাপনার ৪টি মৌলিক বৈশিষ্ট্য যা নিশ্চিত করে যে ডেটাবেইসে ডেটা নির্ভুল, নির্ভরযোগ্য ও সুরক্ষিত থাকবে।
ACID এর পুরো অর্থ:

A – Atomicity
C – Consistency
I – Isolation
D – Durability

🔹 1. Atomicity (পরমাণবিকতা)

ব্যাখ্যা: একটি ট্রানজ্যাকশন সম্পূর্ণ সফল হতে হবে অথবা একদমই হবে না। আংশিকভাবে কোন কাজ হবে না।

উদাহরণ:
ধরো, একজন ব্যবহারকারী তার একাউন্ট থেকে টাকা ট্রান্সফার করছে অন্য একাউন্টে।

প্রথমে টাকা কাটবে
তারপর সেই টাকা অন্য একাউন্টে যোগ হবে

যদি প্রথম ধাপে টাকা কাটে কিন্তু দ্বিতীয় ধাপে কোনো কারণে যোগ না হয়, তাহলে পুরো ট্রানজ্যাকশন rollback হয়ে যাবে। অর্থাৎ, টাকা কাটা হবে না — এটা Atomicity।

🔹 2. Consistency (সামঞ্জস্যতা)

ব্যাখ্যা: ট্রানজ্যাকশনের পরে ডেটাবেইস অবশ্যই একটি valid বা consistent state এ থাকতে হবে।

উদাহরণ:
ধরো ব্যালেন্স ট্রান্সফার করার নিয়ম হলো – একাউন্টে ন্যূনতম ৫০০ টাকা থাকতে হবে।
যদি ২০০ টাকা থাকা অবস্থায় ১০০ টাকা ট্রান্সফার করার চেষ্টা করে, তাহলে consistency rule ভেঙে যাবে, তাই এমন ট্রানজ্যাকশন সফল হবে না।

🔹 3. Isolation (পৃথকতা)

ব্যাখ্যা: একাধিক ট্রানজ্যাকশন একসাথে চললেও, তারা যেন একে অপরের উপর প্রভাব না ফেলে এবং প্রতিটির রেজাল্ট যেন আলাদা ভাবেই নির্ভরযোগ্য থাকে।

উদাহরণ:
ধরো একই সময় দুইজন ইউজার একাউন্ট ব্যালেন্স আপডেট করছে। Isolation নিশ্চিত করে যেন একটির আপডেট অন্যটির ডেটা corrupt না করে। না হলে race condition বা dirty read হতে পারে।

🔹 4. Durability (স্থায়িত্ব)

ব্যাখ্যা: একবার ট্রানজ্যাকশন সফল হলে তা স্থায়ীভাবে ডেটাবেইসে থেকে যাবে, সার্ভার রিস্টার্ট হলেও মুছে যাবে না।

উদাহরণ:
একজন ইউজার পেমেন্ট করে এবং ট্রানজ্যাকশন সফল হয়। এরপর হঠাৎ সার্ভার বন্ধ হয়ে যায়। কিন্তু যখন আবার চালু হয়, তখনও সেই ট্রানজ্যাকশন ডেটাবেইসে পাওয়া যায়। এটাই Durability।

🧠 ACID ব্যবহার কেন গুরুত্বপূর্ণ?

ডেটা corruption রোধ করে
ডেটার নির্ভরযোগ্যতা বজায় রাখে
ব্যাঙ্কিং, e-commerce বা multi-user system এ consistency নিশ্চিত করে
সার্ভার failure হলেও data safe থাকে

✅ সংক্ষেপে মনে রাখার টিপস:

🔸 SQL JOIN সম্পর্কিত প্রশ্ন ও উত্তরঃ

প্রশ্ন ১১: SQL JOIN কী?

উত্তর:

JOIN ব্যবহার করে একাধিক টেবিল থেকে সম্পর্কযুক্ত ডেটা একত্রে আনা হয়।

প্রশ্ন ১২: INNER JOIN কী?

উত্তর:

দুই টেবিলের যেসব রেকর্ড ম্যাচ করে কেবল সেগুলোই দেখায়।

প্রশ্ন ১৩: LEFT JOIN এবং RIGHT JOIN এর পার্থক্য কী?

উত্তর:

LEFT JOIN: বাম টেবিলের সব রেকর্ড এবং ডান টেবিলের ম্যাচ করা রেকর্ড
RIGHT JOIN: ডান টেবিলের সব রেকর্ড এবং বাম টেবিলের ম্যাচ করা রেকর্ড

প্রশ্ন ১৪: FULL OUTER JOIN কী করে?

উত্তর:

দুই টেবিলের সব রেকর্ড দেখায়, যদি না ম্যাচ করে তবে null দেখায়।

প্রশ্ন ১৫: SELF JOIN কী?

উত্তর:

যখন একটি টেবিলকে নিজের সাথেই JOIN করা হয় তখন তাকে SELF JOIN বলে। সাধারণত হায়ারার্কিকাল ডেটা (যেমন employee-manager) এর জন্য ব্যবহৃত হয়।

প্রশ্ন 16: View এবং Materialized View এর মধ্যে পার্থক্য কী?

উত্তর:

View হলো একটি ভার্চুয়াল টেবিল যা একটি SQL query এর উপর ভিত্তি করে তৈরি হয়। এতে মূল ডেটা থাকে না, কেবল query চলে।
Materialized View হলো এমন একটি ভিউ যেটি query এর রেজাল্টকে ফিজিক্যালি স্টোর করে রাখে, ফলে দ্রুত অ্যাক্সেস পাওয়া যায়।

প্রশ্ন 17: Stored Procedure ও Function এর মধ্যে পার্থক্য কী?

উত্তর:

Stored Procedure একাধিক স্টেটমেন্টের সমন্বয়ে তৈরি এবং এটি return না-ও করতে পারে।
Function সর্বদা একটি মান return করে এবং সাধারণত SELECT statement এর মধ্যে ব্যবহার হয়।

প্রশ্ন 18: Index কীভাবে কাজ করে? এবং কখন Index ব্যবহার করা উচিত নয়?

উত্তর:

Index ডেটা স্ট্রাকচার (যেমন B-Tree) ব্যবহার করে সার্চ অপারেশন দ্রুত করে।
Index ব্যবহার করা উচিত নয় যদি:

আপনি খুবই ছোট টেবিল নিয়ে কাজ করছেন
আপনি প্রচুর insert/update/delete করছেন (কারণ এগুলো index রিফ্রেশ করতে হয়)
আপনি এমন কলামে index করছেন যেখানে ভ্যালুগুলোর ভ্যারিয়েশন খুব কম (low cardinality)

প্রশ্ন 19: Query Optimization কীভাবে করবেন?

উত্তর:

প্রয়োজনহীন SELECT * বাদ দিয়ে নির্দিষ্ট কলাম বেছে নিন
Index ব্যবহার করুন
Subquery এর বদলে JOIN ব্যবহার করুন
Query Execution Plan (EXPLAIN) দেখে বুঝুন কোথায় সময় বেশি লাগছে
Aggregate query গুলোতে GROUP BY সাবধানে ব্যবহার করুন

প্রশ্ন 20: Database Sharding ও Replication এর মধ্যে পার্থক্য কী?

উত্তর:

Sharding: ডেটা কে horizontally বিভিন্ন সার্ভারে ভাগ করে রাখে (বড় ডেটাবেইসে লোড কমাতে)
Replication: একই ডেটা একাধিক সার্ভারে কপি করে রাখা হয় (failover ও read-performance বাড়াতে)

প্রশ্ন 21: Deadlock কী এবং এটি কীভাবে হ্যান্ডেল করবেন?

উত্তর:

Deadlock তখন ঘটে যখন দুটি বা ততোধিক ট্রানজ্যাকশন একে অপরের রিসোর্সের জন্য অপেক্ষা করতে থাকে এবং কেউই কাজ শেষ করতে পারে না।

Deadlock হ্যান্ডেল করার উপায়ঃ

লক নেবার order ঠিক রাখা
ছোট transaction রাখা
Retry mechanism যুক্ত করা
Timeout ব্যবহার করা

প্রশ্ন 22: ORM (যেমন Eloquent) ব্যবহার করলে performance issue হতে পারে কেন?

উত্তর:

Eager loading না করলে N+1 problem হয়
Unnecessary query generate হয় যদি যথাযথভাবে scope বা relationship define না করা হয়
Raw SQL বা optimized query ব্যবহারে performance অনেক বেড়ে যেতে পারে ORM এর তুলনায়

প্রশ্ন 23: Eager Loading vs Lazy Loading — পার্থক্য কী?

উত্তর:

Eager Loading: একসাথে related ডেটা লোড করে (query optimization friendly)
Lazy Loading: যখন প্রয়োজন হয় তখন related ডেটা লোড করে (ধীরে কাজ করে, N+1 problem হতে পারে)

প্রশ্ন 24: Transaction isolation level গুলো কী কী?

উত্তর:

Read Uncommitted: অন্য ট্রানজ্যাকশন থেকে uncommitted ডেটা পড়া যায় (Dirty Read)
Read Committed: কেবল committed ডেটা পড়ে
Repeatable Read: একই query বারবার করলে একই রেজাল্ট পাবেন
Serializable: সর্বোচ্চ নিরাপত্তা, ট্রানজ্যাকশন একে অপরের মতো behave করে যেন সিঙ্গেল থ্রেডে হচ্ছে

প্রশ্ন 25: “EXPLAIN” কমান্ড কী এবং এটি কেন ব্যবহার করা হয়?

উত্তর:

EXPLAIN কমান্ড দিয়ে SQL query এর execution plan দেখা যায়। এটি দেখায় কোন টেবিল কখন স্ক্যান হচ্ছে, কোন index ব্যবহার হচ্ছে ইত্যাদি — performance tuning এর জন্য এটি খুব গুরুত্বপূর্ণ।

প্রশ্ন 26: SQL এর ক্যাটাগরিগুলো ও তাদের কাজ?

উত্তর:

i. DDL (Data Definition Language)

👉 উদ্দেশ্য: ডেটাবেইসের স্ট্রাকচার বা স্কিমা তৈরি ও পরিবর্তন করা।

ii. DML (Data Manipulation Language)

👉 উদ্দেশ্য: ডেটা ইনসার্ট, আপডেট বা ডিলিট করা।

JS IQ - Level 1 - Part 2 (Pondit)

Ruhul Amin Sujon — Thu, 24 Apr 2025 15:06:39 +0000

Javascript:

Closure
Prototype
Event loop
async await
Execution context: :(js code run krlei EC create hobe): two parts.
a. Memory component ( Variable Environment): stored variables and functions as key value pairs
b. Code component ( Thread of execution ): code

2. Execution context phases: Running Javascript code creates an execution context. Execution context is created in two phases.
a. Creation phase ( Memory creation phase )
b. Execution phase ( Code execution phase )

3. Call Stack: To manage Global and Local execution contexts, javascript uses a stack which is called Call-Stack (execution context stack, program stack, control stack, run time stack, machine stack).

4. Hoisting:
a. Arrow function behaves like a variable
b. In creation phase variables are assigned undefined
c. function name stores the whole function body as value

Not Defined means the variable is not defined, and undefined means the variable is not assigned value.
Javascript is a loosely types or weakly typed language.

7. Scope: it means where we can access a specific variable or function in our code. Scope is directly dependent on the Lexical Environment.

8. Lexical Environment: Lexical environment is the local memory of execution context along with the lexical environment of it’s parent. (lexical means ‘in hierarchy’ or ‘in sequence’)

function a() {

            var b = 10;

            c();

            function c() {

            }

}

a()

Now we can say, c function is lexically sitting in a function. or c is hierarchically inside in a.

9. Scope chain: The way javascript searches for variables from it’s local memory to the lexical environment of it’s parent, is called scope chain. Or the chain of lexical environments is called scope chain.

10. Temporal Dead Zone: Temporal dead zone is the time since when the let variable is hoisted and till it is initialized some value. At the time of temporal dead zone, if we try to access a variable, it will give us a reference error.

11. Block: Block is defined by { } these curly braces. It is also known as Compound statement. In block let and const variables are stored in block scope, but var variables are stored in global scope. So we say, let & const are in block scoped.

12. Shadowing: Variable shadowing refers to the practice of naming two variables – for example, a global and local variable or a local variable and a callback function parameter – with the same name and within scopes that overlap.

13. Closure: Function along with its lexical environment forms a closure. When a function is returned from a function, the returned function still keeps it’s lexical scope.

14. Differences: Function statement, function expression, function declaration, anonymous function, Named function expression, parameters vs arguments, first class function, arrow function

Call stack is in JS engine and JS enfine is the browser. The browser is powerdun. It has the following features:

a. Timer
b. Geo location
c. Url
d. Console
e. Local storage etc.

To access these, Browsers provide some web apis. Those are:

a. SetTimeout()
b. Dom apis (document.*)
c. Fetch()
d. localStorage
e. console
f. location

we can get these web apis in the Call Stack because of the Global object. Global object is Window in the browser.

16. Callback Queue or Task Queue: The callback function of the setTimeout is registered in a browser. When the timer of the browser understands that the time is expored, the callback function is passed to the callback queue.

17. Event Loop: It is ultimately a checker, just checks the callback queue whether there is anything to execute. Then if the call stack is empty, it passed that item wrapping with an execution context to be executed on call stack.

18. Microtask queue: It is similar to callback queue. But it has a higher priority than the callback queue. Callback functions of fetch api are passed to the microtask queue.

19. Microtasks: All the callback functions returned from promises are microtasks. They are passed to the mocrotask queue.

20. Starvation of callback functions: If a callback function from microtask queue creates another microtask and that creates another microtask and that goes on, the callback function of the callback queue is never executed. This scenario is called starvation of callback function in the callback queue.

Short Syllabus

1. Data Structure:

a. Linked list
b. Double linked list
c. Binary search tree
d. Stack
e. Queue

2. Algorithm:

a. Time complexity
b. Space complexity
c. Selection sort (Time complexity & space complexity)
d. Insertion sort (Time complexity & space complexity)
e. Bubble sort (Time complexity & space complexity)
f. Merge sort (Time complexity & space complexity)
g. Quick sort (Time complexity & space complexity)

3. Database

a. Er diagram
b. Various keys(foreign key,primary,unique,candidate,composite key)
c. Relation:
i. One to one
ii. One to many
iii. Many to one
iv. Many to many
d. Join:
i. Left inner join
ii. Right inner join
iii. Cross join
iv. Outer join

e. Transaction
f. Trigger
g. Function
h. Indexing

4. OOP

a. Encapsulation
b. Inheritance
c. polymorphism
d. Compile time polymorphism vs run time polymorphism
e. abstraction
f. Abstract class
g. Access modifier
h. Multiple inheritance vs multilevel inheritance
i. Interface
j. Overloading vs overriding

5. Networking

a. Network 7 layer
b. Tcp vs udp
c. Application of tcp vs udp

JS IQ - Level 1 - Part 1

Ruhul Amin Sujon — Thu, 24 Apr 2025 14:49:08 +0000

প্রশ্ন ১. JavaScript কী এবং এটি কীভাবে কাজ করে?

উত্তর:

JavaScript হলো একটি ডাইনামিক, হালকা এবং ইভেন্ট-ড্রিভেন প্রোগ্রামিং ভাষা, যা ওয়েব পেজে ইন্টার‍্যাক্টিভ ফিচার যুক্ত করতে ব্যবহৃত হয়। এটি ব্রাউজারে রান করার জন্য JavaScript Engine ব্যবহার করে। উদাহরণস্বরূপ, Chrome-এ V8 Engine এবং Firefox-এ SpiderMonkey।

প্রশ্ন ২. JavaScript-এর ভেরিয়েবল ডিক্লারেশনের জন্য var, let এবং const এর মধ্যে পার্থক্য কী?

উত্তর:

প্রশ্ন ৩. Arrow Function এবং Regular Function-এর মধ্যে পার্থক্য কী?

উত্তর:

i. Arrow Function:

this কনটেক্সট প্যারেন্ট অবজেক্টের সাথে বাঁধা।
সংক্ষিপ্ত সিনট্যাক্স।

ii. Regular Function:

this কনটেক্সট নিজের অবজেক্টের সাথে বাঁধা।
আরও বিস্তারিত কোড লিখতে হয়।

উদাহরণ:

// Regular Function
function add(a, b) {
  return a + b;
}

// Arrow Function
const add = (a, b) => a + b;

প্রশ্ন ৪. JavaScript-এর == এবং === এর মধ্যে পার্থক্য কী?

উত্তর:

== (Loose Equality): ডাটা টাইপ ইগনোর করে শুধু ভ্যালু চেক করে।
=== (Strict Equality): ভ্যালু এবং টাইপ দুটোই চেক করে।

উদাহরণ:

console.log(5 == '5');  // true  
console.log(5 === '5'); // false

প্রশ্ন ৫. JavaScript-এ Closures কী?

উত্তর:

Closure হলো একটি ফাংশন, যা তার আশেপাশের স্কোপ থেকে ভ্যারিয়েবলের অ্যাক্সেস রাখে, এমনকি সেই স্কোপ শেষ হলেও।

উদাহরণ:

function outerFunction() {
  let count = 0;
  return function innerFunction() {
    count++;
    return count;
  };
}

const counter = outerFunction();
console.log(counter()); // 1
console.log(counter()); // 2

প্রশ্ন ৬. JavaScript-এ Event Loop কী?

উত্তর:

Event Loop হলো একটি মেকানিজম, যা কলব্যাক কিউতে থাকা কাজগুলো একটার পর একটা প্রক্রিয়া করে। এটি JavaScript-এর single-threaded asynchronous nature ম্যানেজ করে।

ধাপ:

Call Stack
Web APIs
Callback Queue
Event Loop

উদাহরণ:

console.log('Start');
setTimeout(() => console.log('Middle'), 1000);
console.log('End');

// Output: Start -> End -> Middle

প্রশ্ন ৭. JavaScript-এ async এবং await কী?

উত্তর:

async: একটি ফাংশনকে asynchronous বানায়।
await: একটি প্রমিস রেজল্ভ না হওয়া পর্যন্ত অপেক্ষা করে।

উদাহরণ:

async function fetchData() {
  const response = await fetch('https://api.example.com/data');
  const data = await response.json();
  console.log(data);
}
fetchData();

প্রশ্ন ৮. JavaScript-এ Hoisting কী?

উত্তর:

Hoisting হলো একটি প্রক্রিয়া, যেখানে ভ্যারিয়েবল এবং ফাংশন ডিক্লারেশনগুলো স্কোপের শীর্ষে নিয়ে যাওয়া হয়।

উদাহরণ:

console.log(a); // undefined
var a = 10;

console.log(b); // ReferenceError
let b = 20;

প্রশ্ন ৯. JavaScript-এ call(), apply(), এবং bind() এর মধ্যে পার্থক্য কী?

উত্তর:

call(): ফাংশনকে ইনভোক করে এবং আর্গুমেন্ট আলাদাভাবে পাস করে।
apply(): ফাংশনকে ইনভোক করে এবং আর্গুমেন্ট একটি অ্যারে হিসেবে পাস করে।
bind(): নতুন ফাংশন তৈরি করে এবং আর্গুমেন্ট পরে পাস করা যায়।

উদাহরণ:

const obj = { name: 'Ruhul' };

function greet(greeting) {
  console.log(`${greeting}, ${this.name}`);
}

greet.call(obj, 'Hello');  // Hello, Ruhul
greet.apply(obj, ['Hi']);  // Hi, Ruhul
const boundGreet = greet.bind(obj);
boundGreet('Hey');         // Hey, Ruhul

প্রশ্ন ১০. Promises কী এবং এটি কীভাবে কাজ করে?

উত্তর:

Promise হলো একটি JavaScript অবজেক্ট, যা অ্যাসিনক্রোনাস অপারেশনের সফলতা বা ব্যর্থতার রেজাল্ট রিপ্রেজেন্ট করে।

উদাহরণ:

const promise = new Promise((resolve, reject) => {
  let success = true;
  if (success) {
    resolve('Operation Successful');
  } else {
    reject('Operation Failed');
  }
});

promise
  .then((result) => console.log(result))  // Operation Successful
  .catch((error) => console.log(error));

প্রশ্ন ১১. JavaScript-এ this কী?

উত্তর:

this হলো একটি কিওয়ার্ড, যা বর্তমান অবজেক্টকে রেফার করে। এটি কনটেক্সটের উপর নির্ভর করে পরিবর্তিত হয়।

উদাহরণ:

const obj = {
  name: 'Ruhul',
  greet() {
    console.log(`Hello, ${this.name}`);
  }
};

obj.greet(); // Hello, Ruhul

প্রশ্ন ১২. JavaScript-এ Debouncing এবং Throttling-এর মধ্যে পার্থক্য কী?

উত্তর:

Debouncing: একটি ফাংশন নির্দিষ্ট সময়ের পরে ট্রিগার হয়।
Throttling: একটি ফাংশন একটি নির্দিষ্ট সময়ের ব্যবধানে বারবার ট্রিগার হয়।

উদাহরণ:

Debouncing:

function debounce(func, delay) {
  let timer;
  return function(...args) {
    clearTimeout(timer);
    timer = setTimeout(() => func(...args), delay);
  };
}

Throttling:

function throttle(func, limit) {
  let inThrottle;
  return function(...args) {
    if (!inThrottle) {
      func(...args);
      inThrottle = true;
      setTimeout(() => (inThrottle = false), limit);
    }
  };
}

প্রশ্ন 13. JavaScript-এ Prototype কী এবং এটি কীভাবে কাজ করে?

উত্তর:

Prototype হলো JavaScript-এর একটি মেকানিজম, যা অবজেক্টের মধ্যে প্রপার্টি এবং মেথড শেয়ার করার সুযোগ দেয়। প্রতিটি অবজেক্টের একটি prototype থাকে এবং এটি তার প্যারেন্ট অবজেক্টের প্রপার্টি এবং মেথড অ্যাক্সেস করতে পারে।

উদাহরণ:

function Person(name) {
  this.name = name;
}

Person.prototype.sayHello = function() {
  console.log(`Hello, my name is ${this.name}`);
};

const ruhul = new Person('Ruhul');
ruhul.sayHello(); // Hello, my name is Ruhul

প্রশ্ন 14. JavaScript-এ Event Delegation কী?

উত্তর:

Event Delegation হলো একটি টেকনিক, যেখানে কোনো প্যারেন্ট এলিমেন্টের মাধ্যমে এর চাইল্ড এলিমেন্টের ইভেন্ট হ্যান্ডল করা হয়।

কেন প্রয়োজন:

কম মেমরি ব্যবহার।
নতুন চাইল্ড এলিমেন্ট যোগ করলেও ইভেন্ট কাজ করবে।

উদাহরণ:

document.getElementById('parent').addEventListener('click', function(event) {
  if (event.target && event.target.tagName === 'BUTTON') {
    console.log(`Button ${event.target.innerText} clicked`);
  }
});

প্রশ্ন 15. JavaScript-এ WeakMap এবং WeakSet কী?

উত্তর:

WeakMap: শুধুমাত্র অবজেক্টকে কী হিসেবে ধরে।
WeakSet: শুধুমাত্র অবজেক্টকে ভ্যালু হিসেবে সংরক্ষণ করে।

প্রধান বৈশিষ্ট্য:

গার্বেজ কালেক্টর অব্যবহৃত অবজেক্ট সরিয়ে দেয়।
size, keys(), values() প্রভৃতি নেই।

উদাহরণ:

let weakMap = new WeakMap();
let obj = {};
weakMap.set(obj, 'value');

let weakSet = new WeakSet();
weakSet.add(obj);

প্রশ্ন 16. Currying কী এবং এটি কেন ব্যবহার করা হয়?

উত্তর:

Currying হলো একটি ফাংশনকে একাধিক আর্গুমেন্টের পরিবর্তে এক এক করে আর্গুমেন্ট পাস করার মতো ফাংশনে রূপান্তর করা।

কেন ব্যবহার করা হয়:

কোড পুনর্ব্যবহারযোগ্য।
ডেটা প্রক্রিয়াকরণ সহজ হয়।

উদাহরণ:

function curry(f) {
  return function(a) {
    return function(b) {
      return f(a, b);
    };
  };
}

function sum(a, b) {
  return a + b;
}

const curriedSum = curry(sum);
console.log(curriedSum(2)(3)); // 5

প্রশ্ন 17. JavaScript-এ Memoization কী?

উত্তর:

Memoization হলো একটি অপ্টিমাইজেশন টেকনিক, যা আগের ফলাফল ক্যাশ করে রাখে এবং একই ইনপুট পেলে তা সরাসরি ফেরত দেয়।

উদাহরণ:

function memoize(fn) {
  const cache = {};
  return function(...args) {
    const key = JSON.stringify(args);
    if (cache[key]) return cache[key];
    const result = fn(...args);
    cache[key] = result;
    return result;
  };
}

function slowFunction(num) {
  console.log('Calculating...');
  return num * 2;
}

const fastFunction = memoize(slowFunction);
console.log(fastFunction(5)); // Calculating... 10
console.log(fastFunction(5)); // 10

প্রশ্ন 18. JavaScript-এ Generators এবং Iterators কী?

উত্তর:

Generators: ফাংশন, যা function* সিনট্যাক্স ব্যবহার করে এবং yield কিওয়ার্ড দিয়ে একাধিক মান প্রদান করতে পারে।
Iterators: অবজেক্ট, যা next() মেথড ব্যবহার করে পরবর্তী মান প্রদান করে।

উদাহরণ:

function* generatorFunction() {
  yield 1;
  yield 2;
  yield 3;
}

const iterator = generatorFunction();
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: undefined, done: true }

প্রশ্ন 19. JavaScript-এ Object.create() কীভাবে কাজ করে?

উত্তর:

Object.create() একটি নতুন অবজেক্ট তৈরি করে, যা নির্দিষ্ট প্রোটোটাইপ অবজেক্টের সাথে সংযুক্ত।

উদাহরণ:

const parent = { greet: function() { console.log('Hello'); } };
const child = Object.create(parent);
child.greet(); // Hello

প্রশ্ন 20. JavaScript-এ Debouncing এবং Throttling-এর পার্থক্য কী?

উত্তর:

উদাহরণ:

// Debounce
function debounce(func, delay) {
  let timer;
  return function(...args) {
    clearTimeout(timer);
    timer = setTimeout(() => func(...args), delay);
  };
}

// Throttle
function throttle(func, limit) {
  let inThrottle;
  return function(...args) {
    if (!inThrottle) {
      func(...args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

প্রশ্ন 21. JavaScript-এ Promise.all এবং Promise.race কী?

উত্তর:

Promise.all: সব প্রমিস সফল হলে একটি একক প্রমিস রেজল্ভ হয়।
Promise.race: প্রথম সফল বা ব্যর্থ হওয়া প্রমিসের রেজাল্ট রিটার্ন করে।

উদাহরণ:

const p1 = new Promise((resolve) => setTimeout(resolve, 100, 'One'));
const p2 = new Promise((resolve) => setTimeout(resolve, 200, 'Two'));

Promise.all([p1, p2]).then(console.log); // ['One', 'Two']
Promise.race([p1, p2]).then(console.log); // 'One'