Sending Messages

// services/sent.service.ts
async send(input: SentMessageInput): Promise<SendCanonicalResponse> {
  try {
    const response = await this.client.messages.send({
      to: input.to,
      channel: input.channel,
      template: input.template,
      sandbox: input.sandbox,
    });

    const data = response.data ?? {};
    const recipients = data.recipients ?? [];
    return {
      status: data.status,
      templateId: data.template_id,
      templateName: data.template_name,
      recipients: recipients.map((r) => ({
        id: r.message_id,       // ← message_id → id
        to: r.to,
        channel: r.channel,
        body: r.body,
      })),
    };
  } catch (error) {
    throw this.toApiError(error, 'Failed to send message');
  }
}

# app/services/sent_service.py
async def send_canonical(self, request: CanonicalSendRequest) -> CanonicalSendResponse:
    template: dict[str, object] = {"parameters": request.template.parameters}
    if request.template.id is not None:
        template["id"] = request.template.id
    if request.template.name is not None:
        template["name"] = request.template.name

    response = await self._client.messages.send(
        to=request.to,
        template=template,
        channel=request.channel,
        sandbox=request.sandbox,
    )
    data = response.data
    recipients = data.recipients if data and data.recipients else []
    return CanonicalSendResponse(
        status=getattr(data, "status", None),
        templateId=getattr(data, "template_id", None),
        templateName=getattr(data, "template_name", None),
        recipients=[
            CanonicalRecipient(
                id=r.message_id,   # ← message_id → id
                to=r.to,
                channel=r.channel,
                body=r.body,
            )
            for r in recipients
        ],
    )

// internal/models/contract.go — map the SDK response to the contract shape.
func NewSendMessageContractResponse(data sentdm.MessageSendResponseData) SendMessageContractResponse {
    recipients := make([]MessageRecipient, 0, len(data.Recipients))
    for _, r := range data.Recipients {
        recipients = append(recipients, MessageRecipient{
            ID:      r.MessageID, // ← message_id → id
            To:      r.To,
            Channel: r.Channel,
            Body:    r.Body,
        })
    }
    return SendMessageContractResponse{
        Status:       data.Status,
        TemplateID:   data.TemplateID,
        TemplateName: data.TemplateName,
        Recipients:   recipients,
    }
}

// internal/services/sentclient.go — the thin wrapper (note: Sandbox, not TestMode).
func (c *SentClient) SendMessageRaw(ctx context.Context, params sentdm.MessageSendParams) (*sentdm.MessageSendResponse, error) {
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()
    return c.client.Messages.Send(ctx, params)
}

// service/impl/CanonicalMessageServiceImpl.java
public CanonicalSendResponse send(CanonicalSendRequest request) {
    SentClient sentClient = clientProvider.client();
    MessageSendResponse response = sentClient.messages().send(buildParams(request));
    var data = response.data().orElseThrow(() -> new RuntimeException("Empty response data"));
    String status = data.status().orElse("QUEUED");
    var recipients = data.recipients().orElse(List.of()).stream()
            .map(r -> new CanonicalSendResponse.Recipient(
                    r.messageId().orElse(""),   // ← message_id → id
                    r.to().orElse(""),
                    r.channel().orElse(null),
                    r.body().orElse(null)))
            .toList();
    return new CanonicalSendResponse(status,
            data.templateId().orElse(null), data.templateName().orElse(null), recipients);
}

// Services/SentDmService.cs
public async Task<CanonicalSendResponse> SendCanonicalAsync(
    CanonicalSendRequest request, CancellationToken ct = default)
{
    var parameters = new MessageSendParams
    {
        Template = new Sentdm.Models.Messages.Template
        {
            ID = request.Template.Id,
            Name = request.Template.Name,
            Parameters = request.Template.Parameters ?? new Dictionary<string, string>()
        },
        To = request.To.ToArray(),
        Channel = request.Channel is { Count: > 0 } ? request.Channel.ToArray() : null,
        Sandbox = request.Sandbox
    };

    var result = await Client.Messages.Send(parameters, ct).ConfigureAwait(false);
    var data = result.Data;

    var recipients = (data?.Recipients ?? Array.Empty<Recipient>())
        .Select(r => new CanonicalRecipient(
            r.MessageID ?? string.Empty,   // ← message_id → id
            r.To ?? string.Empty, r.Channel ?? string.Empty, r.Body ?? string.Empty))
        .ToList();

    return new CanonicalSendResponse(
        data?.Status ?? string.Empty, data?.TemplateID, data?.TemplateName, recipients);
}

// app/Services/SentDM/SentDMService.php
public function send(array $to, ?array $channel, array $template, bool $sandbox = false): array
{
    $response = $this->client->messages->send(
        to: $to,
        template: [
            'id' => $template['id'] ?? null,
            'name' => $template['name'] ?? null,
            'parameters' => $template['parameters'] ?? [],
        ],
        channel: $channel,
        sandbox: $sandbox,
    );

    $data = $response->data;
    $recipients = array_map(fn ($r) => [
        'id' => $r->messageID,   // ← message_id → id
        'to' => $r->to,
        'channel' => $r->channel,
        'body' => $r->body,
    ], $data->recipients ?? []);

    return [
        'status' => $data->status,
        'templateId' => $data->templateID,
        'templateName' => $data->templateName,
        'recipients' => $recipients,
    ];
}

# app/services/sent_dm/send_message_service.rb
def call
  validate!

  response = client.messages.send_(
    to: recipients,   # an array — one call can fan out to many recipients
    template: { id: template_id, name: template_name, parameters: variables },
    channel: channels   # the Ruby SDK parameter is `channel:` (an array)
  )

  success(
    status: response.data.status,
    recipients: response.data.recipients.map do |r|
      { id: r.message_id, to: r.to, channel: r.channel, body: r.body }   # ← message_id → id
    end
  )
rescue ApplicationService::ValidationError => e
  failure(:validation_error, e.message)
rescue StandardError => e
  handle_api_error(e)
end