Setting Up the Project: SDK, Config, and Folder Layout

npm install @sentdm/sentdm
# or: pnpm add @sentdm/sentdm  ·  yarn add @sentdm/sentdm

pip install sentdm
# or: uv add sentdm

go get github.com/sentdm/sent-dm-go

<!-- Maven -->
<dependency>
  <groupId>dm.sent</groupId>
  <artifactId>sent-java</artifactId>
  <version><!-- pin the latest release; see the SDK reference --></version>
</dependency>

dotnet add package Sentdm

composer require sentdm/sent-dm-php

bundle add sentdm
# or: gem install sentdm

import SentDm from "@sentdm/sentdm";

// One typed client, per request, bound to the caller's key.
const client = new SentDm({ apiKey });
const res = await client.messages.send({ to, template });

// A hand-rolled client: you own the transport and the envelope.
export class SentV3Client {
  constructor(private opts: { apiKey: string; baseUrl: string }) {}

  async request<T>(method: string, path: string, body?: unknown): Promise<T> {
    const res = await fetch(`${this.opts.baseUrl}${path}`, {
      method,
      headers: {
        "x-api-key": this.opts.apiKey,
        "content-type": "application/json",
        accept: "application/json",
      },
      body: body === undefined ? undefined : JSON.stringify(body),
    });
    const parsed = JSON.parse(await res.text());
    if (!res.ok || !parsed?.success) {
      throw new SentV3ApiError(parsed?.error?.message ?? res.statusText, res.status);
    }
    return parsed.data as T; // unwrap the { success, data, error, meta } envelope
  }
}

import { z } from "zod";

const envSchema = z.object({
  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
  PORT: z.string().transform(Number).default("3001"),
  // Operational knobs only. NOT the API key (per-request), and the webhook
  // secret is a runtime value — optional here, not required at boot.
  SENT_DM_WEBHOOK_SECRET: z.string().min(1).optional(),
  LOG_LEVEL: z.enum(["trace", "debug", "info", "warn", "error", "fatal"]).default("info"),
  RATE_LIMIT_WINDOW_MS: z.string().transform(Number).default("900000"),
  RATE_LIMIT_MAX_REQUESTS: z.string().transform(Number).default("100"),
});

const parsed = envSchema.safeParse(process.env);
if (!parsed.success) {
  console.error("Invalid environment variables:", parsed.error.format());
  process.exit(1); // fail fast
}
export const env = parsed.data;

from functools import lru_cache
from pydantic import Field
from pydantic_settings import BaseSettings, SettingsConfigDict


class Settings(BaseSettings):
    model_config = SettingsConfigDict(env_file=".env", extra="ignore")

    debug: bool = Field(default=False, alias="DEBUG")
    # Optional runtime convenience only — not required at boot.
    sent_dm_webhook_secret: str | None = Field(default=None, alias="SENT_DM_WEBHOOK_SECRET")
    sent_base_url: str | None = Field(default=None, alias="SENT_BASE_URL")
    rate_limit: str = Field(default="100/minute", alias="RATE_LIMIT")
    log_level: str = Field(default="INFO", alias="LOG_LEVEL")


@lru_cache
def get_settings() -> Settings:
    return Settings()  # pydantic raises on invalid config at first access

// Loaded with envconfig (kelseyhightower/envconfig); viper works the same way.
type Config struct {
	Server    ServerConfig
	Sent      SentConfig
	RateLimit RateLimitConfig
}

type ServerConfig struct {
	Port        string `envconfig:"PORT" default:"3031"`
	Environment string `envconfig:"ENVIRONMENT" default:"development"`
}

// Per-customer RUNTIME value, optional env fallback for dev/curl. Never
// required to boot the server.
type SentConfig struct {
	WebhookSecret string `envconfig:"SENT_DM_WEBHOOK_SECRET"`
}

type RateLimitConfig struct {
	RequestsPerSecond float64 `envconfig:"RATE_LIMIT_RPS" default:"10"`
	BurstSize         int     `envconfig:"RATE_LIMIT_BURST" default:"20"`
}

func Load() (*Config, error) {
	var cfg Config
	if err := envconfig.Process("", &cfg); err != nil {
		return nil, fmt.Errorf("failed to load config: %w", err) // fail fast
	}
	return &cfg, nil
}

// config/sent.php — operational knobs only, sourced from env at boot.
return [
    'base_url' => env('SENT_BASE_URL', 'https://api.sent.dm'),
    // Optional runtime convenience only — never required to boot.
    'webhook_secret' => env('SENT_DM_WEBHOOK_SECRET'),
    'rate_limit' => env('RATE_LIMIT', '100,1'), // "max,per-minute"
];

<?php
// app/Providers/SentConfigServiceProvider.php — fail fast on boot.

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use RuntimeException;

class SentConfigServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        $baseUrl = config('sent.base_url');
        if (empty($baseUrl) || ! filter_var($baseUrl, FILTER_VALIDATE_URL)) {
            throw new RuntimeException('Invalid or missing SENT_BASE_URL.');
        }
        // No SENT_DM_API_KEY check here — it's a per-request value, not config.
    }
}