Node.js / TypeScript

Node.js / TypeScript Examples

Complete integration examples using Node.js with TypeScript.

Setup

npm install node-fetch
# or use the built-in fetch in Node.js 18+

API Client Class

A reusable client for the N’entropy EUDR Integration API:

const BASE_URL = "https://backend.joinnentropy.com/api/v1/integration";

interface ApiResponse<T> {
  success: boolean;
  data: T;
  error?: string;
}

class EUDRClient {
  private apiKey: string;

  constructor(apiKey: string) {
    this.apiKey = apiKey;
  }

  private async request<T>(
    method: string,
    path: string,
    body?: unknown,
  ): Promise<T> {
    const res = await fetch(`${BASE_URL}${path}`, {
      method,
      headers: {
        Authorization: `Bearer ${this.apiKey}`,
        "Content-Type": "application/json",
      },
      body: body ? JSON.stringify(body) : undefined,
    });

    if (!res.ok) {
      const error = await res.json();
      throw new Error(`API Error ${res.status}: ${error.error?.message}`);
    }

    const json: ApiResponse<T> = await res.json();
    return json.data;
  }

  // Suppliers
  async upsertSuppliers(suppliers: SupplierInput[]) {
    return this.request("POST", "/suppliers", { suppliers });
  }

  async getSuppliers(params?: { page?: number; limit?: number }) {
    const query = new URLSearchParams();
    if (params?.page) query.set("page", String(params.page));
    if (params?.limit) query.set("limit", String(params.limit));
    return this.request("GET", `/suppliers?${query}`);
  }

  // Products
  async upsertProducts(products: ProductInput[]) {
    return this.request("POST", "/products", { products });
  }

  async getProducts(params?: { page?: number; limit?: number }) {
    const query = new URLSearchParams();
    if (params?.page) query.set("page", String(params.page));
    if (params?.limit) query.set("limit", String(params.limit));
    return this.request("GET", `/products?${query}`);
  }

  // Batches
  async upsertBatches(batches: BatchInput[]) {
    return this.request("POST", "/batches", { batches });
  }

  // Sync status
  async getSyncStatus(entityType?: string) {
    const query = entityType ? `?entityType=${entityType}` : "";
    return this.request("GET", `/sync-status${query}`);
  }

  // DDS status
  async getDDSStatus(batchExternalId: string) {
    return this.request("GET", `/dds/${batchExternalId}`);
  }
}

// Type definitions
interface SupplierInput {
  externalId: string;
  name: string;
  country?: string;
  address?: string;
  city?: string;
  email?: string;
  phone?: string;
  taxId?: string;
}

interface ProductInput {
  externalId: string;
  name: string;
  hsCode?: string;
  description?: string;
  supplierExternalId?: string;
}

interface BatchInput {
  externalId: string;
  productExternalId: string;
  quantity?: number;
  unit?: string;
  batchDate?: string;
}

Usage Examples

Sync Suppliers from Your System

const client = new EUDRClient("eudr_live_abc123...");

// Fetch suppliers from your database
const mySuppliers = await db.query("SELECT * FROM suppliers");

// Transform and sync
const result = await client.upsertSuppliers(
  mySuppliers.map((s) => ({
    externalId: s.id,
    name: s.company_name,
    country: s.country_code,
    address: s.street_address,
    city: s.city,
    email: s.contact_email,
    phone: s.phone,
    taxId: s.vat_number,
  })),
);

console.log(`Synced: ${result.created} created, ${result.updated} updated`);

Sync Products with Supplier Association

const client = new EUDRClient("eudr_live_abc123...");

const result = await client.upsertProducts([
  {
    externalId: "PROD-001",
    name: "Brazilian Eucalyptus Timber",
    hsCode: "4407.11",
    description: "Sustainably sourced eucalyptus planks",
    supplierExternalId: "SUP-100", // Links to previously synced supplier
  },
  {
    externalId: "PROD-002",
    name: "Indonesian Palm Oil",
    hsCode: "1511.10",
    supplierExternalId: "SUP-200",
  },
]);

console.log(result);

Create Batches

const client = new EUDRClient("eudr_live_abc123...");

const result = await client.upsertBatches([
  {
    externalId: "BATCH-2024-001",
    productExternalId: "PROD-001",
    quantity: 5000,
    unit: "kg",
    batchDate: "2024-06-15",
  },
]);

Check DDS Status

const client = new EUDRClient("eudr_live_abc123...");

const ddsStatus = await client.getDDSStatus("BATCH-2024-001");

console.log("DDS Status:", ddsStatus);
// {
//   batch: { externalId: 'BATCH-2024-001', ... },
//   product: { name: 'Brazilian Eucalyptus Timber', ... },
//   supplier: { name: 'Amazon Timber Co.', ... },
//   ddsSubmissions: [{ status: 'submitted', submittedAt: '...' }]
// }

Webhook Verification

import { createHmac, timingSafeEqual } from "crypto";
import express from "express";

const app = express();
app.use(express.raw({ type: "application/json" }));

function verifyWebhook(
  payload: Buffer,
  signature: string,
  secret: string,
): boolean {
  const expected = createHmac("sha256", secret).update(payload).digest("hex");

  const sig = signature.replace("sha256=", "");
  return timingSafeEqual(Buffer.from(sig), Buffer.from(expected));
}

app.post("/webhooks/eudr", (req, res) => {
  const signature = req.headers["x-webhook-signature"] as string;
  const secret = process.env.WEBHOOK_SECRET!;

  if (!verifyWebhook(req.body, signature, secret)) {
    return res.status(401).json({ error: "Invalid signature" });
  }

  const event = JSON.parse(req.body.toString());

  switch (event.event) {
    case "supplier.created":
      console.log("New supplier synced:", event.data);
      break;
    case "sync.completed":
      console.log("Sync finished:", event.data);
      break;
    case "dds.status_changed":
      console.log("DDS status update:", event.data);
      break;
  }

  res.json({ received: true });
});

app.listen(3000);

Error Handling

async function syncWithRetry(
  client: EUDRClient,
  suppliers: SupplierInput[],
  maxRetries = 3,
) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await client.upsertSuppliers(suppliers);
    } catch (error: any) {
      if (error.message.includes("429")) {
        // Rate limited — wait and retry
        const waitMs = Math.pow(2, attempt) * 1000;
        console.log(`Rate limited, retrying in ${waitMs}ms...`);
        await new Promise((r) => setTimeout(r, waitMs));
        continue;
      }
      if (attempt === maxRetries) throw error;
    }
  }
}