graph LR
    subgraph RedwoodJS Application
        subgraph Web Side (React)
            A[React Component] -- GraphQL Mutation --> B(GraphQL Server);
        end
        subgraph API Side (Node.js)
            B -- Calls --> C{Message Service};
            C -- Stores/Retrieves --> D[(Database)];
            E{Webhook Function} -- Receives POST --> F[Webhook Handler Logic];
            F -- Stores --> D;
        end
    end

    subgraph Sinch Cloud
        G[Sinch API]
        H[Sinch Virtual Number]
        I[Sinch Webhook Service]
    end

    C -- Sends SMS via API --> G;
    UserMobile -- Sends SMS --> H;
    H -- Triggers Webhook --> I;
    I -- POST Request --> E;
    G -- Sends SMS --> UserMobile;

    style D fill:#f9f,stroke:#333,stroke-width:2px

yarn create redwood-app ./redwood-sinch-messaging
cd redwood-sinch-messaging

yarn workspace api add @sinch/sdk-core cross-fetch

# .env

# Database Connection (IMPORTANT: Replace with your actual DB connection string)
DATABASE_URL="postgresql://postgres:password@localhost:5432/redwood_sinch?schema=public"

# Sinch API Credentials (IMPORTANT: Replace with your values from the Sinch Dashboard)
# Go to Sinch Dashboard -> Access Keys -> Create API Key
SINCH_PROJECT_ID="YOUR_SINCH_PROJECT_ID"
SINCH_KEY_ID="YOUR_SINCH_KEY_ID"
SINCH_KEY_SECRET="YOUR_SINCH_KEY_SECRET"

# Sinch Virtual Number (IMPORTANT: Replace with your rented number in E.164 format, e.g., +12035551212)
# Go to Sinch Dashboard -> Numbers -> Active Numbers
SINCH_NUMBER="YOUR_SINCH_VIRTUAL_NUMBER"

# Webhook Security (IMPORTANT: Replace with a strong random string you generate)
# You can use `openssl rand -base64 32` or an online generator
SINCH_WEBHOOK_SECRET="YOUR_STRONG_RANDOM_WEBHOOK_SECRET"

# Sinch API Region (Optional, defaults typically work, but specify if needed: 'us' or 'eu')
# SINCH_REGION="us"

// api/src/lib/sinch.js
import { SinchClient } from '@sinch/sdk-core'
import { logger } from 'src/lib/logger'

let sinchClientInstance = null

export const getSinchClient = () => {
  if (sinchClientInstance) {
    return sinchClientInstance
  }

  const projectId = process.env.SINCH_PROJECT_ID
  const keyId = process.env.SINCH_KEY_ID
  const keySecret = process.env.SINCH_KEY_SECRET

  if (!projectId || !keyId || !keySecret || projectId === 'YOUR_SINCH_PROJECT_ID') {
    logger.error('Sinch API credentials missing or still using placeholder values in environment variables. Please check your .env file.')
    // In a real app, you might throw an error or handle this more gracefully
    // depending on whether Sinch is critical at startup.
    return null // Prevent using invalid client
  }

  try {
    sinchClientInstance = new SinchClient({
      projectId,
      keyId,
      keySecret,
      // Optional: Specify region if needed, e.g., smsRegion: 'EU'
      // smsRegion: process.env.SINCH_REGION || 'US', // Default to US if not set
    })
    logger.info('Sinch client initialized successfully.')
    return sinchClientInstance
  } catch (error) {
    logger.error({ error }, 'Failed to initialize Sinch client')
    return null // Return null on initialization failure
  }
}

// Optional: Pre-initialize on server start to catch config errors early
// getSinchClient()

// api/db/schema.prisma

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

generator client {
  provider      = ""prisma-client-js""
  binaryTargets = ""native""
}

// Add this Message model
model Message {
  id           String    @id @default(cuid())
  externalId   String?   @unique // Sinch's message ID
  body         String
  fromNumber   String    // Sender's number (E.164)
  toNumber     String    // Recipient's number (E.164)
  direction    Direction // INBOUND or OUTBOUND
  status       String?   // Optional: Status from Sinch (e.g., 'DELIVERED', 'FAILED')
  sentAt       DateTime? // Timestamp when sent (for outbound)
  receivedAt   DateTime? // Timestamp when received (for inbound)
  createdAt    DateTime  @default(now())
  updatedAt    DateTime  @updatedAt
}

enum Direction {
  INBOUND
  OUTBOUND
}

yarn rw prisma migrate dev

yarn rw g service messages

// api/src/services/messages/messages.js
import { db } from 'src/lib/db'
import { logger } from 'src/lib/logger'
import { getSinchClient } from 'src/lib/sinch'
import { requireAuth } from 'src/lib/auth' // Example auth import

export const messages = () => {
  // Example: Retrieve all messages (implement pagination later)
  // requireAuth() // Secure this endpoint if needed
  return db.message.findMany({ orderBy: { createdAt: 'desc' } })
}

export const message = ({ id }) => {
  // requireAuth() // Secure this endpoint if needed
  return db.message.findUnique({
    where: { id },
  })
}

// Function to send an SMS
export const sendSms = async ({ input }) => {
  // Ensure user is authenticated/authorized before sending
  // requireAuth({ roles: ['admin', 'sender'] }) // Example authorization

  const sinchClient = getSinchClient()
  if (!sinchClient) {
    throw new Error('Sinch client not available. Check configuration.')
  }

  const { to, body } = input
  const fromNumber = process.env.SINCH_NUMBER

  if (!to || !body) {
    throw new Error('Recipient number (to) and message body are required.')
  }
  if (!fromNumber || fromNumber === 'YOUR_SINCH_VIRTUAL_NUMBER') {
    throw new Error('Sinch sender number (SINCH_NUMBER) is not configured or is using placeholder. Check .env file.')
  }

  // Basic validation (improve as needed, e.g., check E.164 format)
  if (!/^\+\d+$/.test(to) || !/^\+\d+$/.test(fromNumber)) {
      logger.warn(`Invalid E.164 format detected. To: ${to}, From: ${fromNumber}`);
      // Depending on strictness, you might throw an error here
      // throw new Error('Invalid phone number format. Use E.164 (e.g., +12223334444).')
  }

  logger.info(`Attempting to send SMS from ${fromNumber} to ${to}`)

  let messageRecord // To store the DB record

  try {
    // 1. Record the attempt in the database BEFORE sending
    messageRecord = await db.message.create({
      data: {
        fromNumber: fromNumber,
        toNumber: to,
        body: body,
        direction: 'OUTBOUND',
        status: 'PENDING', // Initial status
      },
    })

    // 2. Send the message via Sinch SMS API
    // Note: The Conversation API can also send SMS, but the dedicated SMS API
    // might be simpler for just sending. Let's use the SMS API here via sdk-core.
    const response = await sinchClient.sms.batches.send({
      sendSMSRequestBody: {
        to: [to], // Expects an array of recipients
        from: fromNumber,
        body: body,
        // Optional parameters: delivery_report, client_reference, etc.
        // client_reference: messageRecord.id // Link Sinch message to DB record
      },
    })

    logger.info({ sinchResponse: response }, 'SMS sent successfully via Sinch')

    // 3. Update the database record with Sinch ID and potentially status
    // Note: The 'send' response confirms acceptance by Sinch, not final delivery.
    // Final status comes via webhooks (Delivery Reports - not covered in this basic guide).
    const updatedMessage = await db.message.update({
      where: { id: messageRecord.id },
      data: {
        externalId: response.id, // Store the Sinch batch ID
        status: 'SENT', // Or 'ACCEPTED' - indicates Sinch accepted it
        sentAt: response.created_at ? new Date(response.created_at) : new Date(), // Use Sinch timestamp if available
      },
    })

    return updatedMessage // Return the updated DB record

  } catch (error) {
    logger.error({ error, messageInput: input }, 'Failed to send SMS')

    // 4. Update DB record on failure
    if (messageRecord) {
      await db.message.update({
        where: { id: messageRecord.id },
        data: {
          status: 'FAILED',
          // Optionally store error details if your schema allows
        },
      }).catch(dbError => logger.error({ dbError }, 'Failed to update message status after send error'));
    }

    // Re-throw a user-friendly error or handle specific Sinch errors
    if (error.response?.data) {
      // Try to get specific Sinch error details
      throw new Error(`Sinch API Error: ${JSON.stringify(error.response.data)}`)
    }
    throw new Error(`Failed to send SMS: ${error.message}`)
  }
}

# api/src/graphql/messages.sdl.js
export const schema = gql`
  type Message {
    id: String!
    externalId: String
    body: String!
    fromNumber: String!
    toNumber: String!
    direction: Direction!
    status: String
    sentAt: DateTime
    receivedAt: DateTime
    createdAt: DateTime!
    updatedAt: DateTime!
  }

  enum Direction {
    INBOUND
    OUTBOUND
  }

  type Query {
    messages: [Message!]! @requireAuth
    message(id: String!): Message @requireAuth
  }

  input SendSmsInput {
    to: String!       # Recipient phone number in E.164 format
    body: String!     # Message content
  }

  type Mutation {
    sendSms(input: SendSmsInput!): Message! @requireAuth # Add appropriate role checks if needed
  }
`

yarn rw g function inboundSms --typescript=false # or true if using TS

// api/src/functions/inboundSms.js
import { logger } from 'src/lib/logger'
import { db } from 'src/lib/db'
import crypto from 'crypto' // Node.js crypto module for verification

// --- Webhook Security Verification ---
const verifySinchSignature = (req) => {
  const sinchSignature = req.headers['x-sinch-signature']
  const timestamp = req.headers['x-sinch-timestamp']
  const webhookSecret = process.env.SINCH_WEBHOOK_SECRET

  // Check for missing headers or secret (including placeholder value)
  if (!sinchSignature || !timestamp || !webhookSecret || webhookSecret === 'YOUR_STRONG_RANDOM_WEBHOOK_SECRET') {
    logger.error('Missing Sinch signature headers, webhook secret, or secret is still placeholder.')
    return false
  }

  // Check if timestamp is recent (e.g., within 5 minutes) to prevent replay attacks
  const FIVE_MINUTES_IN_MS = 5 * 60 * 1000
  const requestTime = new Date(timestamp).getTime()
  const currentTime = new Date().getTime()

  if (isNaN(requestTime) || Math.abs(currentTime - requestTime) > FIVE_MINUTES_IN_MS) {
    logger.warn(`Sinch webhook timestamp is invalid or too old (${timestamp}). Possible replay attack or clock skew.`)
    return false
  }

  // **CRITICAL NOTE on Raw Body Access:**
  // Signature verification requires the *exact raw request body* as sent by Sinch.
  // Standard serverless environments (like default Redwood deployments on Netlify/Vercel)
  // often parse JSON payloads *before* your function runs, making the raw body inaccessible.
  // The `JSON.stringify(event.body)` approach below is a *workaround* that might
  // succeed *only if* the parsing and re-stringifying process doesn't alter whitespace,
  // key order, or character encoding compared to the original raw body.
  // **This workaround is NOT guaranteed to be reliable in production.**
  // For robust production verification, you **MUST** ensure access to the raw request body.
  // This typically requires:
  //   a) A custom server file setup in Redwood where you can use middleware (like `express.raw()`) before JSON parsing.
  //   b) Deployment platforms/configurations that explicitly provide the raw body.
  const requestBody = req.body // This is the potentially unreliable stringified body from handler
  if (typeof requestBody !== 'string') {
      logger.error('Webhook body for signature verification was not a string. Raw body likely unavailable.')
      return false;
  }
  const stringToSign = `${requestBody}|${timestamp}`

  try {
    const expectedSignature = crypto
      .createHmac('sha256', webhookSecret)
      .update(stringToSign)
      .digest('base64')

    // Use crypto.timingSafeEqual for security against timing attacks
    if (crypto.timingSafeEqual(Buffer.from(sinchSignature, 'base64'), Buffer.from(expectedSignature, 'base64'))) {
      logger.debug('Sinch webhook signature verified successfully.')
      return true
    } else {
      logger.error('Invalid Sinch webhook signature.')
      // Log details for debugging (avoid logging secret or full body in prod if sensitive)
      // logger.debug({ sinchSignature, timestamp, calculatedSignature: expectedSignature, stringToSign }, 'Signature mismatch details');
      return false
    }
  } catch (error) {
      logger.error({ error }, 'Error during signature comparison.');
      return false;
  }
}


export const handler = async (event, context) => {
  logger.info('inboundSms function invoked')

  // --- 1. Security First: Verify the webhook signature ---
  // Attempt verification using the potentially unreliable re-stringified body.
  // See critical note in verifySinchSignature function above.
  let pseudoRawBody
  try {
      // Redwood/Lambda often provides parsed JSON in event.body for application/json
      pseudoRawBody = JSON.stringify(event.body)
  } catch (stringifyError) {
      logger.error({ stringifyError }, 'Could not stringify event.body for signature check.');
       return {
          statusCode: 400, // Bad Request
          body: JSON.stringify({ error: 'Invalid request body format' }),
          headers: { 'Content-Type': 'application/json' },
       }
  }

  const pseudoReq = { headers: event.headers, body: pseudoRawBody }

  if (!verifySinchSignature(pseudoReq)) {
    logger.error('Webhook signature verification failed.')
    return {
      statusCode: 401, // Unauthorized
      body: JSON.stringify({ error: 'Invalid signature' }),
      headers: { 'Content-Type': 'application/json' },
    }
  }

  // --- 2. Process the Inbound Message Event ---
  const payload = event.body // Use the already parsed body

  // Check if it's an inbound message event from Sinch Conversation API
  // Structure might vary slightly; adapt based on actual Sinch payloads you receive.
  if (payload?.event === 'MESSAGE_INBOUND' && payload?.message?.direction === 'INCOMING') {
    const message = payload.message
    const contactMessage = message.contact_message

    // Ensure it's a text message (ignore MMS, etc. for this guide)
    if (contactMessage?.text_message) {
      const text = contactMessage.text_message.text
      const from = message.contact_id // Sender's ID (usually phone number for SMS)
      const to = message.channel_identity?.identity // Recipient ID (your Sinch number)
      const externalId = message.id // Sinch's ID for this message
      const receivedTimestamp = payload.accepted_time ? new Date(payload.accepted_time) : new Date()

      if (!from || !to || !externalId) {
          logger.error({ payload }, 'Received inbound message payload missing critical fields (contact_id, channel_identity.identity, message.id).')
          // Return 400 as the payload is malformed for our needs
          return { statusCode: 400, body: JSON.stringify({ error: 'Malformed payload' }) }
      }

      logger.info(`Received inbound SMS from ${from} to ${to}`)

      try {
        // Optional: Check if message already exists using externalId to ensure idempotency
        const existingMessage = await db.message.findUnique({ where: { externalId } });
        if (existingMessage) {
            logger.warn(`Received duplicate webhook for message ${externalId}. Skipping storage.`);
            return { statusCode: 200, body: JSON.stringify({ message: 'Duplicate webhook ignored' }) };
        }

        // Store the message
        await db.message.create({
          data: {
            externalId: externalId,
            body: text,
            fromNumber: from, // Assuming contact_id is E.164 number
            toNumber: to,     // Assuming channel_identity is E.164 number
            direction: 'INBOUND',
            status: 'RECEIVED',
            receivedAt: receivedTimestamp,
          },
        })

        logger.info(`Inbound message ${externalId} stored successfully.`)

        // Optional: Add logic here to *reply* to the message
        // e.g., call the sendSms service function we created earlier
        // Be careful not to create infinite loops!
        // Example reply:
        // if (text.toLowerCase().includes('help')) {
        //   await sendSms({ input: { to: from, body: 'Help is on the way!' }})
        // }

      } catch (error) {
        logger.error({ error, externalId, payload }, 'Failed to store inbound message')
        // Return 500 so Sinch might retry (configure retry policy in Sinch dashboard)
        return {
          statusCode: 500,
          body: JSON.stringify({ error: 'Failed to process message internally' }),
          headers: { 'Content-Type': 'application/json' },
        }
      }
    } else {
      logger.warn({ messageId: message.id }, 'Received non-text contact message type, skipping storage.')
    }
  } else {
    // Log other event types if needed for debugging, but don't treat as errors
    logger.info({ eventType: payload?.event, direction: payload?.message?.direction }, 'Received non-inbound message event type or unexpected structure, skipping.')
  }

  // --- 3. Acknowledge Receipt ---
  // Respond to Sinch quickly to acknowledge receipt of the webhook.
  return {
    statusCode: 200,
    body: JSON.stringify({ message: 'Webhook received and processed' }),
    headers: { 'Content-Type': 'application/json' },
  }
}