Zindua for Fastify

# Zindua SDK (official npm package)
npm i @zindua/sdk

# Fastify: your HTTP framework (not published by Zindua)
npm i fastify

# .env
ZINDUA_API_KEY=znd_test_your_key_here

import type { FastifyInstance } from "fastify";
import type { ZinduaSendResult } from "@zindua/sdk";

const sendOtpSchema = {
  body: {
    type: "object",
    required: ["to", "code"],
    properties: {
      to: { type: "string", format: "email" },
      code: { type: "string", minLength: 4, maxLength: 8 },
      lang: { type: "string", enum: ["fr", "en"] },
    },
  },
} as const;

fastify.post<{ Body: { to: string; code: string; lang?: string } }>(
  "/otp/email",
  { schema: sendOtpSchema },
  async (request, reply): Promise<ZinduaSendResult> => {
    const { to, code, lang } = request.body;
    return zindua.send({
      to,
      template: "otp-verification",
      ...(lang ? { lang } : {}),
      variables: { code },
    });
  }
);

await zindua.send({
  to: "user@example.com",
  template: "invoice-ready",
  variables: { name: "Alex", amount: "49.00" },
  cc: "billing@myapp.com",
  replyTo: "support@myapp.com",
  // attachments: [{ url: "https://cdn.myapp.com/invoice.pdf" }],
});

// Zindua delivers the message. Your app owns OTP state.
import Redis from "ioredis";

const redis = new Redis(process.env.REDIS_URL);

fastify.post("/otp/request", async (request, reply) => {
  const { email } = request.body as { email: string };
  const code = String(Math.floor(100000 + Math.random() * 900000));

  await redis.setex(`otp:${email}`, 600, code);

  const result = await fastify.zindua.send({
    to: email,
    template: "otp-verification",
    variables: { code },
  });

  // Save logId to correlate with Dashboard → Logs or webhooks
  return reply.code(202).send({ ok: true, logId: result.logId });
});

fastify.post("/otp/verify", async (request, reply) => {
  const { email, code } = request.body as { email: string; code: string };
  const stored = await redis.get(`otp:${email}`);
  if (stored !== code) return reply.code(401).send({ error: "Invalid code" });
  await redis.del(`otp:${email}`);
  return { ok: true };
});

{
  "success": true,
  "status": "queued",
  "logId": "550e8400-e29b-41d4-a716-446655440000",
  "channel": "email",
  "langUsed": "fr",
  "langFallback": false,
  "testMode": false,
  "project": "My App",
  "context": {
    "plan": { "slug": "free", "emailQuota": 25000, "emailsUsed": 12 },
    "channels": { "email": true, "whatsapp": false }
  }
}

import { Zindua, ZinduaError } from "@zindua/sdk";

fastify.setErrorHandler((error, request, reply) => {
  if (error instanceof ZinduaError) {
    const status = error.status && error.status >= 400 ? error.status : 502;
    return reply.code(status).send({
      error: error.message,
      code: error.code,
      details: error.details,
    });
  }
  throw error;
});

// In a route:
try {
  const result = await zindua.send({ to, template: "otp-verification", variables: { code } });
  return reply.code(202).send(result);
} catch (e) {
  if (e instanceof ZinduaError && e.code === "TEMPLATE_NOT_FOUND") {
    return reply.code(404).send({ error: "Template missing in dashboard" });
  }
  throw e;
}

import fp from "fastify-plugin";
import { Zindua } from "@zindua/sdk";

declare module "fastify" {
  interface FastifyInstance {
    zindua: Zindua;
  }
}

export default fp(async (fastify) => {
  const client = new Zindua({
    apiKey: process.env.ZINDUA_API_KEY!,
    siteUrl: process.env.ZINDUA_SITE_URL,
    timeoutMs: 45_000,
  });
  fastify.decorate("zindua", client);
});

// In routes: fastify.zindua.send({ ... })

const { templates } = await zindua.getTemplates();
// [{ slug: "otp-verification", langs: ["fr", "en"], variables: ["code", "appName"], ... }]

const project = await zindua.getProject();
// Plan, channel checklist, default language

npx @zindua/cli@latest doctor