+-------------------+      +-----------------------+      +----------------+
|   Client/Frontend | ---> | Next.js API Route     | ---> | Infobip SMS API|
| (e.g., Admin UI)  |      | (/api/send-bulk-sms)  |      |                |
+-------------------+      +-----------------------+      +----------------+
                             |  - Validate Request   |
                             |  - Format Payload     |
                             |  - Call Infobip API   |
                             |  - Handle Response    |
                             |  - Log Results/Errors |
                             +-----------------------+
                                       | (Optional: Logging)
                                       v
                             +-----------------------+
                             |      Logging Service  |
                             +-----------------------+
                                       | (Optional: DB Interaction)
                                       v
                             +-----------------------+
                             |       Database        |
                             | (Recipients, Logs)    |
                             +-----------------------+
                                       | (Optional: Delivery Reports)
                                       v
                             +-----------------------+
                             | Next.js API Route     | <--- | Infobip Webhook|
                             | (/api/infobip-webhook)|      | (notifyUrl)    |
                             +-----------------------+      +----------------+

npx create-next-app@latest infobip-sms-sender

cd infobip-sms-sender

npm install axios
# or
# yarn add axios

#.env.local

# Infobip Credentials - Obtain from your Infobip account dashboard
INFOBIP_API_KEY=YOUR_INFOBIP_API_KEY
INFOBIP_BASE_URL=YOUR_INFOBIP_BASE_URL

# Default Sender ID (Optional - can be overridden per request)
INFOBIP_DEFAULT_SENDER_ID=InfoSMS

# .gitignore - should already contain this if using create-next-app defaults
.env*.local

src/
└── app/
    ├── api/
    │   └── send-bulk-sms/
    │       └── route.js  # Our main API endpoint logic
    ├── layout.js
    └── page.js
.env.local
package.json
# ... other files

// src/app/api/send-bulk-sms/route.js
import { NextResponse } from 'next/server';
import axios from 'axios';

// --- Configuration ---
const INFOBIP_API_KEY = process.env.INFOBIP_API_KEY;
const INFOBIP_BASE_URL = process.env.INFOBIP_BASE_URL;
const DEFAULT_SENDER_ID = process.env.INFOBIP_DEFAULT_SENDER_ID || 'InfoSMS';

// Basic input validation helper
function validateInput(data) {
    if (!data || typeof data !== 'object') {
        return 'Invalid request body: Expected an object.';
    }
    const { recipients_ text_ senderId } = data;
    if (!Array.isArray(recipients) || recipients.length === 0) {
        return 'Invalid input: ""recipients"" must be a non-empty array of phone numbers (strings).';
    }
    if (!recipients.every(num => typeof num === 'string' && num.trim().length > 0)) {
        return 'Invalid input: All items in ""recipients"" array must be non-empty strings.';
    }
    if (typeof text !== 'string' || text.trim().length === 0) {
        return 'Invalid input: ""text"" must be a non-empty string.';
    }
    if (senderId && typeof senderId !== 'string') {
        return 'Invalid input: ""senderId"" must be a string if provided.';
    }
    // Add more specific validation (e.g., phone number format) if needed
    return null; // Validation passed
}

// --- API Handler ---
export async function POST(request) {
    console.log('Received request to /api/send-bulk-sms');

    // --- Check Credentials ---
    if (!INFOBIP_API_KEY || !INFOBIP_BASE_URL) {
        console.error('Server configuration error: Infobip API Key or Base URL is missing.');
        return NextResponse.json(
            { error: 'Server configuration error. Please contact the administrator.' },
            { status: 500 }
        );
    }

    let requestBody;
    try {
        requestBody = await request.json();
    } catch (error) {
        console.error('Failed to parse request body:', error);
        return NextResponse.json({ error: 'Invalid JSON in request body.' }, { status: 400 });
    }

    // --- Validate Input ---
    const validationError = validateInput(requestBody);
    if (validationError) {
        console.warn('Input validation failed:', validationError);
        return NextResponse.json({ error: validationError }, { status: 400 });
    }

    const { recipients, text, senderId } = requestBody;
    const effectiveSenderId = senderId || DEFAULT_SENDER_ID;

    // --- Prepare Infobip Payload ---
    // This payload targets the Infobip endpoint: /sms/2/text/advanced
    // Map recipients array to Infobip's expected `destinations` format
    const destinations = recipients.map(phoneNumber => ({ to: phoneNumber }));

    const infobipPayload = {
        messages: [
            {
                from: effectiveSenderId,
                destinations: destinations,
                text: text,
                // Optional: Add other Infobip parameters here if needed
                // notifyUrl: 'YOUR_DELIVERY_REPORT_WEBHOOK_URL',
                // notifyContentType: 'application/json',
                // callbackData: 'Your custom tracking data',
            },
        ],
        // Optional: Define a bulkId for tracking this batch
        // bulkId: `my-campaign-${Date.now()}`
    };

    // --- Call Infobip API ---
    const apiUrl = `https://${INFOBIP_BASE_URL}/sms/2/text/advanced`;
    const headers = {
        'Authorization': `App ${INFOBIP_API_KEY}`, // Use 'App' prefix for newer API keys
        // 'Authorization': `ApiKey ${INFOBIP_API_KEY}`, // Use 'ApiKey' for older keys if 'App' doesn't work
        'Content-Type': 'application/json',
        'Accept': 'application/json',
    };

    try {
        console.log(`Sending ${recipients.length} messages via Infobip...`);
        const response = await axios.post(apiUrl, infobipPayload, { headers });

        console.log('Infobip API Response Status:', response.status);
        console.log('Infobip API Response Body:', response.data);

        // Check for potential partial success/errors within the response body
        if (response.data && response.data.messages) {
            // Group ID 5 often indicates 'REJECTED'. Check Infobip docs for definitive status codes.
            const successfulSends = response.data.messages.filter(
                msg => msg.status && msg.status.groupId !== 5
            );
            const failedSends = response.data.messages.filter(
                msg => msg.status && msg.status.groupId === 5
            );

            console.log(`Successfully submitted ${successfulSends.length} messages to Infobip.`);
            if (failedSends.length > 0) {
                console.warn(`Failed to submit ${failedSends.length} messages to Infobip. Check response body for details.`);
                // Potentially return partial success info
            }
        }

        return NextResponse.json(response.data, { status: response.status });

    } catch (error) {
        console.error('Error calling Infobip API:');
        if (error.response) {
            // The request was made and the server responded with a status code
            // that falls out of the range of 2xx
            console.error('Status:', error.response.status);
            console.error('Headers:', error.response.headers);
            console.error('Data:', error.response.data);
            // Return the error details from Infobip if available
            return NextResponse.json(
                {
                    error: 'Failed to send SMS via Infobip.',
                    infobipError: error.response.data
                },
                { status: error.response.status }
            );
        } else if (error.request) {
            // The request was made but no response was received
            console.error('No response received:', error.request);
            return NextResponse.json(
                { error: 'No response from Infobip API. Check network or Infobip status.' },
                { status: 504 } // Gateway Timeout
            );
        } else {
            // Something happened in setting up the request that triggered an Error
            console.error('Axios setup error:', error.message);
            return NextResponse.json(
                { error: 'Internal server error setting up request.' },
                { status: 500 }
            );
        }
    }
}

{
  ""recipients"": [""+14155552671"", ""+442071234567"", ""+33123456789""],
  ""text"": ""Hello from our Next.js App! Special offer inside."",
  ""senderId"": ""MyAppName""
}

{
  ""bulkId"": ""some-unique-bulk-id-from-infobip"",
  ""messages"": [
    {
      ""to"": ""+14155552671"",
      ""status"": {
        ""groupId"": 1,
        ""groupName"": ""PENDING"",
        ""id"": 7,
        ""name"": ""PENDING_ENROUTE"",
        ""description"": ""Message sent to next instance""
      },
      ""messageId"": ""unique-message-id-1""
    },
    {
      ""to"": ""+442071234567"",
      ""status"": {
        ""groupId"": 1,
        ""groupName"": ""PENDING"",
        ""id"": 7,
        ""name"": ""PENDING_ENROUTE"",
        ""description"": ""Message sent to next instance""
      },
      ""messageId"": ""unique-message-id-2""
    },
    {
      ""to"": ""+33123456789"",
      ""status"": {
        ""groupId"": 5,
        ""groupName"": ""REJECTED"",
        ""id"": 1,
        ""name"": ""REJECTED_DESTINATION"",
        ""description"": ""Invalid destination address.""
       },
       ""messageId"": ""unique-message-id-3""
    }
  ]
}

curl -X POST http://localhost:3000/api/send-bulk-sms \
-H ""Content-Type: application/json"" \
-d '{
  ""recipients"": [""+14155550001"", ""+14155550002""],
  ""text"": ""Test message from cURL!"",
  ""senderId"": ""TestSend""
}'

// Replace console.log/error with logger methods
// import logger from './logger'; // Assuming a logger setup

// ... inside POST handler ...

if (!INFOBIP_API_KEY || !INFOBIP_BASE_URL) {
    logger.error('Server configuration error: Infobip credentials missing.');
    // ... return response
}

// ... inside catch block ...
if (error.response) {
    logger.error({
        message: 'Infobip API Error',
        status: error.response.status,
        data: error.response.data,
        url: apiUrl,
        payload: infobipPayload // Be cautious logging sensitive payload data
    });
    // ... return response
} else if (error.request) {
     logger.error({ message: 'Infobip API No Response', error: error.message, url: apiUrl });
    // ... return response
} else {
    logger.error({ message: 'API Request Setup Error', error: error.message });
    // ... return response
}

npm install prisma --save-dev
npm install @prisma/client
npx prisma init --datasource-provider postgresql # Or your preferred DB

// prisma/schema.prisma
generator client {
  provider = ""prisma-client-js""
}

datasource db {
  provider = ""postgresql"" // Or your chosen provider
  url      = env(""DATABASE_URL"")
}

model Recipient {
  id          String   @id @default(cuid())
  phoneNumber String   @unique // E.164 format
  firstName   String?
  lastName    String?
  // Add other relevant fields (tags, groups, etc.)
  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt

  MessageLogs MessageLog[]
}

model BulkSend {
  id            String   @id @default(cuid())
  infobipBulkId String?  @unique // Store Infobip's bulkId if available
  messageText   String
  senderId      String
  requestedAt   DateTime @default(now())
  status        String   @default(""PENDING"") // e.g., PENDING, PROCESSING, COMPLETED, FAILED

  MessageLogs MessageLog[]
}

model MessageLog {
  id               String    @id @default(cuid())
  infobipMessageId String?   @unique // Store Infobip's messageId
  bulkSendId       String
  recipientId      String    // Foreign key to Recipient table
  status           String    // Initial status from API response (e.g., PENDING_ENROUTE, REJECTED_DESTINATION)
  deliveryStatus   String?   // Final status from webhook (e.g., DELIVERED_TO_HANDSET, FAILED_UNKNOWN)
  statusMessage    String?   // Description from Infobip status
  sentAt           DateTime  @default(now())
  updatedAt        DateTime  @updatedAt
  webhookPayload   Json?     // Store the full delivery report payload

  bulkSend  BulkSend  @relation(fields: [bulkSendId], references: [id])
  recipient Recipient @relation(fields: [recipientId], references: [id])

  @@index([bulkSendId])
  @@index([recipientId])
}

npx prisma migrate dev --name init
# Or for production/non-dev:
# npx prisma db push

// src/app/api/send-bulk-sms/route.js
// ... other imports
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

// ... inside POST handler, after validation ...

let bulkSendRecord;
try {
    // 1. Create a record for the bulk send attempt
    bulkSendRecord = await prisma.bulkSend.create({
        data: {
            messageText: text,
            senderId: effectiveSenderId,
            status: 'PROCESSING', // Mark as processing initially
        },
    });

    // --- Prepare Infobip Payload ---
    // Option A: If recipients in request are DB IDs (e.g., [""id1"", ""id2""])
    // const recipientIds = requestBody.recipients; // Assuming request sends IDs
    // const dbRecipients = await prisma.recipient.findMany({ where: { id: { in: recipientIds } } });
    // const destinations = dbRecipients.map(r => ({ to: r.phoneNumber }));

    // Option B: If recipients in request are phone numbers (as in current example)
    const phoneNumbers = requestBody.recipients;
    const destinations = phoneNumbers.map(phoneNumber => ({ to: phoneNumber }));

    const infobipPayload = { /* ... as before ... */ };
    // Use our DB ID as bulkId for easier linking. Check Infobip docs for any bulkId constraints
    // (e.g., length, format), although a CUID like Prisma's default is likely acceptable.
    infobipPayload.bulkId = bulkSendRecord.id;

    // --- Call Infobip API ---
    const apiUrl = `https://${INFOBIP_BASE_URL}/sms/2/text/advanced`;
    const headers = { /* ... as before ... */ };

    const response = await axios.post(apiUrl, infobipPayload, { headers });

    // 2. Log individual message statuses
    if (response.data && response.data.messages) {
        const messageLogsData = [];
        for (const msg of response.data.messages) {
            // PROBLEM: Mapping 'msg.to' (phone number) back to your internal 'recipientId'
            // This requires fetching recipients based on phone numbers, which can be slow or complex.
            // const recipient = await prisma.recipient.findUnique({ where: { phoneNumber: msg.to } }); // Example lookup
            // const recipientId = recipient ? recipient.id : 'UNKNOWN'; // Handle if number not in DB

            // SIMPLER APPROACH: Store phone number directly in the log if mapping is too complex initially.
            // You might need a separate 'recipientPhoneNumber' field in MessageLog schema for this.
            messageLogsData.push({
                bulkSendId: bulkSendRecord.id,
                // recipientId: recipientId, // Use the mapped ID if available
                // recipientPhoneNumber: msg.to, // Or store the number directly
                infobipMessageId: msg.messageId,
                status: msg.status.name,
                statusMessage: msg.status.description,
                sentAt: new Date(),
            });
        }

        // Consider logging directly without Prisma if mapping complexity is high,
        // or perform lookups asynchronously. For simplicity here, we prepare data.
        console.log('TODO: Save message logs to DB. Data prepared:', messageLogsData);
        // Example DB write (handle potential errors):
        // await prisma.messageLog.createMany({ data: messageLogsData, skipDuplicates: true });
    }

     // 3. Update bulk send status (e.g., to COMPLETED or PARTIAL_FAILURE)
    await prisma.bulkSend.update({
        where: { id: bulkSendRecord.id },
        data: {
            infobipBulkId: response.data.bulkId, // Store Infobip's ID
            status: 'COMPLETED', // Or determine based on message statuses
        },
    });

    return NextResponse.json(response.data, { status: response.status });

} catch (error) {
    // 4. Update bulk send status on failure
    if (bulkSendRecord) {
        await prisma.bulkSend.update({
            where: { id: bulkSendRecord.id },
            data: { status: 'FAILED' },
        });
    }
    // ... rest of error handling ...
} finally {
    await prisma.$disconnect(); // Disconnect Prisma client
}