sendcore 1.0.0

package/README.md

@@ -0,0 +1,195 @@
+# SendCore Node.js SDK
+
+The official Node.js SDK for [SendCore](https://sendcore.elasto.ng) — reliable email infrastructure for developers and businesses.
+
+## Installation
+
+```bash
+npm install sendcore
+```
+
+## Quick Start
+
+```ts
+import { SendCore } from 'sendcore';
+
+const sendcore = new SendCore('sc_live_xxxxxxxxxx');
+
+// Send an email
+await sendcore.emails.send({
+  from: 'hello@yourdomain.com',
+  to: 'user@example.com',
+  subject: 'Welcome!',
+  html: '<h1>Hello World</h1>',
+});
+```
+
+## Features
+
+- **Zero dependencies** — uses native `fetch` (Node 18+)
+- **Full TypeScript support** — complete type definitions included
+- **Automatic retries** — exponential backoff on 5xx errors
+- **Configurable timeouts** — prevent hanging requests
+- **Secure by default** — API key via `x-api-key` header
+
+---
+
+## Configuration
+
+```ts
+import { SendCore } from 'sendcore';
+
+// Simple — just pass your API key
+const sendcore = new SendCore('sc_live_xxxxxxxxxx');
+
+// Advanced — full configuration
+const sendcore = new SendCore({
+  apiKey: 'sc_live_xxxxxxxxxx',
+  baseUrl: 'https://api.sendcore.elasto.ng',  // optional
+  timeout: 30000,                              // optional, ms
+  retries: 2,                                  // optional
+});
+```
+
+Get your API key from the [SendCore Dashboard](https://sendcore.elasto.ng/dashboard/api-keys).
+
+---
+
+## Sending Emails
+
+### Basic Email
+
+```ts
+await sendcore.emails.send({
+  from: 'hello@yourdomain.com',
+  to: 'user@example.com',
+  subject: 'Hello!',
+  html: '<h1>Welcome to our platform</h1>',
+});
+```
+
+### With Multiple Recipients
+
+```ts
+await sendcore.emails.send({
+  from: 'Team <team@yourdomain.com>',
+  to: ['alice@example.com', 'bob@example.com'],
+  cc: 'manager@example.com',
+  bcc: ['audit@yourdomain.com'],
+  subject: 'Team Update',
+  html: '<p>Here is your weekly update.</p>',
+  replyTo: 'support@yourdomain.com',
+});
+```
+
+### Using a Template
+
+```ts
+await sendcore.emails.sendTemplate({
+  from: 'hello@yourdomain.com',
+  to: 'user@example.com',
+  templateId: 'welcome-email',
+  templateData: {
+    name: 'John',
+    plan: 'Pro',
+    loginUrl: 'https://app.example.com/login',
+  },
+});
+```
+
+### With Attachments
+
+```ts
+import { readFileSync } from 'fs';
+
+await sendcore.emails.send({
+  from: 'billing@yourdomain.com',
+  to: 'user@example.com',
+  subject: 'Your Invoice',
+  html: '<p>Please find your invoice attached.</p>',
+  attachments: [
+    {
+      filename: 'invoice.pdf',
+      content: readFileSync('./invoice.pdf').toString('base64'),
+      contentType: 'application/pdf',
+    },
+  ],
+});
+```
+
+### With Tags
+
+```ts
+await sendcore.emails.send({
+  from: 'hello@yourdomain.com',
+  to: 'user@example.com',
+  subject: 'Order Confirmation',
+  html: '<p>Your order is confirmed!</p>',
+  tags: {
+    category: 'transactional',
+    orderId: 'ORD-12345',
+  },
+});
+```
+
+---
+
+## Managing Contacts
+
+### Subscribe a Contact
+
+```ts
+await sendcore.contacts.subscribe({
+  email: 'user@example.com',
+  firstName: 'John',
+  lastName: 'Doe',
+  listId: 'lst_abc123',          // optional
+  customData: { plan: 'pro' },   // optional
+});
+```
+
+### Unsubscribe a Contact
+
+```ts
+await sendcore.contacts.unsubscribe({
+  email: 'user@example.com',
+});
+```
+
+---
+
+## Error Handling
+
+```ts
+import { SendCore, SendCoreError } from 'sendcore';
+
+const sendcore = new SendCore('sc_live_xxxxxxxxxx');
+
+try {
+  await sendcore.emails.send({
+    from: 'hello@yourdomain.com',
+    to: 'user@example.com',
+    subject: 'Test',
+    html: '<p>Hello</p>',
+  });
+} catch (error) {
+  if (error instanceof SendCoreError) {
+    console.error('Status:', error.statusCode);  // e.g. 400, 401, 422
+    console.error('Message:', error.message);
+    console.error('Detail:', error.detail);
+  } else {
+    console.error('Network error:', error);
+  }
+}
+```
+
+---
+
+## Requirements
+
+- **Node.js 18+** (uses native `fetch`)
+- A SendCore API key
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,176 @@
+/** Configuration for the SendCore client */
+interface SendCoreConfig {
+    /** Your API key from the SendCore dashboard */
+    apiKey: string;
+    /** Base URL of the SendCore API (default: https://api.sendcore.elasto.ng) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Number of automatic retries on 5xx errors (default: 2) */
+    retries?: number;
+}
+interface EmailAttachment {
+    /** Filename of the attachment */
+    filename: string;
+    /** Base64-encoded content of the file */
+    content: string;
+    /** MIME content type (e.g. 'application/pdf') */
+    contentType?: string;
+}
+interface SendEmailParams {
+    /** Sender address (e.g. 'John <john@example.com>') */
+    from: string;
+    /** One or more recipient email addresses */
+    to: string | string[];
+    /** Email subject line */
+    subject?: string;
+    /** HTML body of the email */
+    html?: string;
+    /** Plain text body of the email */
+    text?: string;
+    /** CC recipients */
+    cc?: string | string[];
+    /** BCC recipients */
+    bcc?: string | string[];
+    /** Reply-to addresses */
+    replyTo?: string | string[];
+    /** Use a pre-built template by its ID */
+    templateId?: string;
+    /** Variables to inject into the template */
+    templateData?: Record<string, any>;
+    /** File attachments */
+    attachments?: EmailAttachment[];
+    /** Custom tags for tracking and analytics */
+    tags?: Record<string, string>;
+}
+interface SendEmailResponse {
+    id: string;
+    message: string;
+    [key: string]: any;
+}
+interface SubscribeParams {
+    /** Email address of the contact */
+    email: string;
+    /** First name */
+    firstName?: string;
+    /** Last name */
+    lastName?: string;
+    /** ID of the audience list to add the contact to */
+    listId?: string;
+    /** Any additional custom data */
+    customData?: Record<string, any>;
+}
+interface UnsubscribeParams {
+    /** Email address to unsubscribe */
+    email: string;
+}
+interface SendCoreErrorDetail {
+    statusCode: number;
+    message: string;
+    error?: string;
+    [key: string]: any;
+}
+
+/**
+ * SendCore — Official Node.js SDK
+ *
+ * @example
+ * ```ts
+ * import { SendCore } from 'sendcore';
+ *
+ * const sendcore = new SendCore('sc_live_xxxxxxxxxx');
+ *
+ * await sendcore.emails.send({
+ *   from: 'hello@yourdomain.com',
+ *   to: 'user@example.com',
+ *   subject: 'Welcome!',
+ *   html: '<h1>Hello World</h1>',
+ * });
+ * ```
+ */
+declare class SendCore {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly retries;
+    /** Email operations */
+    readonly emails: EmailsResource;
+    /** Audience / contact operations */
+    readonly contacts: ContactsResource;
+    constructor(apiKeyOrConfig: string | SendCoreConfig);
+    /** @internal */
+    _request<T = any>(method: 'GET' | 'POST' | 'PUT' | 'DELETE', path: string, body?: Record<string, any>): Promise<T>;
+}
+declare class EmailsResource {
+    private readonly client;
+    constructor(client: SendCore);
+    /**
+     * Send an email.
+     *
+     * @example
+     * ```ts
+     * const result = await sendcore.emails.send({
+     *   from: 'hello@yourdomain.com',
+     *   to: 'user@example.com',
+     *   subject: 'Hello!',
+     *   html: '<h1>Welcome</h1>',
+     * });
+     * ```
+     */
+    send(params: SendEmailParams): Promise<SendEmailResponse>;
+    /**
+     * Send an email using a pre-built template.
+     *
+     * @example
+     * ```ts
+     * await sendcore.emails.sendTemplate({
+     *   from: 'hello@yourdomain.com',
+     *   to: 'user@example.com',
+     *   templateId: 'welcome-email',
+     *   templateData: { name: 'John', plan: 'Pro' },
+     * });
+     * ```
+     */
+    sendTemplate(params: Omit<SendEmailParams, 'html' | 'text'> & {
+        templateId: string;
+        templateData?: Record<string, any>;
+    }): Promise<SendEmailResponse>;
+}
+declare class ContactsResource {
+    private readonly client;
+    constructor(client: SendCore);
+    /**
+     * Subscribe a contact (add to your audience).
+     *
+     * @example
+     * ```ts
+     * await sendcore.contacts.subscribe({
+     *   email: 'user@example.com',
+     *   firstName: 'John',
+     *   listId: 'lst_abc123',
+     * });
+     * ```
+     */
+    subscribe(params: SubscribeParams): Promise<any>;
+    /**
+     * Unsubscribe a contact from your audience.
+     *
+     * @example
+     * ```ts
+     * await sendcore.contacts.unsubscribe({ email: 'user@example.com' });
+     * ```
+     */
+    unsubscribe(params: UnsubscribeParams): Promise<any>;
+}
+
+/**
+ * Custom error class for SendCore API errors.
+ * Contains the HTTP status code and structured error detail from the server.
+ */
+declare class SendCoreError extends Error {
+    readonly statusCode: number;
+    readonly detail: SendCoreErrorDetail;
+    constructor(statusCode: number, detail: SendCoreErrorDetail);
+}
+
+export { type EmailAttachment, SendCore, type SendCoreConfig, SendCoreError, type SendCoreErrorDetail, type SendEmailParams, type SendEmailResponse, type SubscribeParams, type UnsubscribeParams };

package/dist/index.d.ts

@@ -0,0 +1,176 @@
+/** Configuration for the SendCore client */
+interface SendCoreConfig {
+    /** Your API key from the SendCore dashboard */
+    apiKey: string;
+    /** Base URL of the SendCore API (default: https://api.sendcore.elasto.ng) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Number of automatic retries on 5xx errors (default: 2) */
+    retries?: number;
+}
+interface EmailAttachment {
+    /** Filename of the attachment */
+    filename: string;
+    /** Base64-encoded content of the file */
+    content: string;
+    /** MIME content type (e.g. 'application/pdf') */
+    contentType?: string;
+}
+interface SendEmailParams {
+    /** Sender address (e.g. 'John <john@example.com>') */
+    from: string;
+    /** One or more recipient email addresses */
+    to: string | string[];
+    /** Email subject line */
+    subject?: string;
+    /** HTML body of the email */
+    html?: string;
+    /** Plain text body of the email */
+    text?: string;
+    /** CC recipients */
+    cc?: string | string[];
+    /** BCC recipients */
+    bcc?: string | string[];
+    /** Reply-to addresses */
+    replyTo?: string | string[];
+    /** Use a pre-built template by its ID */
+    templateId?: string;
+    /** Variables to inject into the template */
+    templateData?: Record<string, any>;
+    /** File attachments */
+    attachments?: EmailAttachment[];
+    /** Custom tags for tracking and analytics */
+    tags?: Record<string, string>;
+}
+interface SendEmailResponse {
+    id: string;
+    message: string;
+    [key: string]: any;
+}
+interface SubscribeParams {
+    /** Email address of the contact */
+    email: string;
+    /** First name */
+    firstName?: string;
+    /** Last name */
+    lastName?: string;
+    /** ID of the audience list to add the contact to */
+    listId?: string;
+    /** Any additional custom data */
+    customData?: Record<string, any>;
+}
+interface UnsubscribeParams {
+    /** Email address to unsubscribe */
+    email: string;
+}
+interface SendCoreErrorDetail {
+    statusCode: number;
+    message: string;
+    error?: string;
+    [key: string]: any;
+}
+
+/**
+ * SendCore — Official Node.js SDK
+ *
+ * @example
+ * ```ts
+ * import { SendCore } from 'sendcore';
+ *
+ * const sendcore = new SendCore('sc_live_xxxxxxxxxx');
+ *
+ * await sendcore.emails.send({
+ *   from: 'hello@yourdomain.com',
+ *   to: 'user@example.com',
+ *   subject: 'Welcome!',
+ *   html: '<h1>Hello World</h1>',
+ * });
+ * ```
+ */
+declare class SendCore {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly retries;
+    /** Email operations */
+    readonly emails: EmailsResource;
+    /** Audience / contact operations */
+    readonly contacts: ContactsResource;
+    constructor(apiKeyOrConfig: string | SendCoreConfig);
+    /** @internal */
+    _request<T = any>(method: 'GET' | 'POST' | 'PUT' | 'DELETE', path: string, body?: Record<string, any>): Promise<T>;
+}
+declare class EmailsResource {
+    private readonly client;
+    constructor(client: SendCore);
+    /**
+     * Send an email.
+     *
+     * @example
+     * ```ts
+     * const result = await sendcore.emails.send({
+     *   from: 'hello@yourdomain.com',
+     *   to: 'user@example.com',
+     *   subject: 'Hello!',
+     *   html: '<h1>Welcome</h1>',
+     * });
+     * ```
+     */
+    send(params: SendEmailParams): Promise<SendEmailResponse>;
+    /**
+     * Send an email using a pre-built template.
+     *
+     * @example
+     * ```ts
+     * await sendcore.emails.sendTemplate({
+     *   from: 'hello@yourdomain.com',
+     *   to: 'user@example.com',
+     *   templateId: 'welcome-email',
+     *   templateData: { name: 'John', plan: 'Pro' },
+     * });
+     * ```
+     */
+    sendTemplate(params: Omit<SendEmailParams, 'html' | 'text'> & {
+        templateId: string;
+        templateData?: Record<string, any>;
+    }): Promise<SendEmailResponse>;
+}
+declare class ContactsResource {
+    private readonly client;
+    constructor(client: SendCore);
+    /**
+     * Subscribe a contact (add to your audience).
+     *
+     * @example
+     * ```ts
+     * await sendcore.contacts.subscribe({
+     *   email: 'user@example.com',
+     *   firstName: 'John',
+     *   listId: 'lst_abc123',
+     * });
+     * ```
+     */
+    subscribe(params: SubscribeParams): Promise<any>;
+    /**
+     * Unsubscribe a contact from your audience.
+     *
+     * @example
+     * ```ts
+     * await sendcore.contacts.unsubscribe({ email: 'user@example.com' });
+     * ```
+     */
+    unsubscribe(params: UnsubscribeParams): Promise<any>;
+}
+
+/**
+ * Custom error class for SendCore API errors.
+ * Contains the HTTP status code and structured error detail from the server.
+ */
+declare class SendCoreError extends Error {
+    readonly statusCode: number;
+    readonly detail: SendCoreErrorDetail;
+    constructor(statusCode: number, detail: SendCoreErrorDetail);
+}
+
+export { type EmailAttachment, SendCore, type SendCoreConfig, SendCoreError, type SendCoreErrorDetail, type SendEmailParams, type SendEmailResponse, type SubscribeParams, type UnsubscribeParams };

package/dist/index.js

@@ -0,0 +1,213 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SendCore: () => SendCore,
+  SendCoreError: () => SendCoreError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SendCoreError = class _SendCoreError extends Error {
+  statusCode;
+  detail;
+  constructor(statusCode, detail) {
+    const msg = detail.message || `SendCore API error (${statusCode})`;
+    super(msg);
+    this.name = "SendCoreError";
+    this.statusCode = statusCode;
+    this.detail = detail;
+    Object.setPrototypeOf(this, _SendCoreError.prototype);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.sendcore.elasto.ng";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRIES = 2;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var SDK_VERSION = "1.0.0";
+var SendCore = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  retries;
+  /** Email operations */
+  emails;
+  /** Audience / contact operations */
+  contacts;
+  constructor(apiKeyOrConfig) {
+    const config = typeof apiKeyOrConfig === "string" ? { apiKey: apiKeyOrConfig } : apiKeyOrConfig;
+    if (!config.apiKey) {
+      throw new Error(
+        "SendCore: An API key is required. Get one at https://sendcore.elasto.ng/dashboard/api-keys"
+      );
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.retries = config.retries ?? DEFAULT_RETRIES;
+    this.emails = new EmailsResource(this);
+    this.contacts = new ContactsResource(this);
+  }
+  // ─── Internal HTTP layer ────────────────────
+  /** @internal */
+  async _request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "x-api-key": this.apiKey,
+      "Content-Type": "application/json",
+      "User-Agent": `sendcore-node/${SDK_VERSION}`
+    };
+    const fetchOptions = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(this.timeout),
+      ...body ? { body: JSON.stringify(body) } : {}
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const response = await fetch(url, fetchOptions);
+        const responseBody = await response.json().catch(() => ({}));
+        if (response.ok) {
+          return responseBody;
+        }
+        if (!RETRYABLE_STATUS_CODES.has(response.status)) {
+          throw new SendCoreError(response.status, {
+            statusCode: response.status,
+            message: responseBody.message || response.statusText,
+            error: responseBody.error,
+            ...responseBody
+          });
+        }
+        lastError = new SendCoreError(response.status, {
+          statusCode: response.status,
+          message: responseBody.message || response.statusText,
+          error: responseBody.error,
+          ...responseBody
+        });
+      } catch (err) {
+        if (err instanceof SendCoreError) throw err;
+        lastError = err;
+      }
+      if (attempt < this.retries) {
+        const delay = Math.min(1e3 * 2 ** attempt, 1e4);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    throw lastError ?? new Error("SendCore: Request failed after retries");
+  }
+};
+var EmailsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Send an email.
+   *
+   * @example
+   * ```ts
+   * const result = await sendcore.emails.send({
+   *   from: 'hello@yourdomain.com',
+   *   to: 'user@example.com',
+   *   subject: 'Hello!',
+   *   html: '<h1>Welcome</h1>',
+   * });
+   * ```
+   */
+  async send(params) {
+    if (!params.from) {
+      throw new Error("SendCore: The 'from' field is required to send an email.");
+    }
+    if (!params.to) {
+      throw new Error("SendCore: The 'to' field is required to send an email.");
+    }
+    const payload = {
+      ...params,
+      to: Array.isArray(params.to) ? params.to : [params.to],
+      cc: params.cc ? Array.isArray(params.cc) ? params.cc : [params.cc] : void 0,
+      bcc: params.bcc ? Array.isArray(params.bcc) ? params.bcc : [params.bcc] : void 0,
+      replyTo: params.replyTo ? Array.isArray(params.replyTo) ? params.replyTo : [params.replyTo] : void 0
+    };
+    return this.client._request("POST", "/emails/send", payload);
+  }
+  /**
+   * Send an email using a pre-built template.
+   *
+   * @example
+   * ```ts
+   * await sendcore.emails.sendTemplate({
+   *   from: 'hello@yourdomain.com',
+   *   to: 'user@example.com',
+   *   templateId: 'welcome-email',
+   *   templateData: { name: 'John', plan: 'Pro' },
+   * });
+   * ```
+   */
+  async sendTemplate(params) {
+    return this.send(params);
+  }
+};
+var ContactsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Subscribe a contact (add to your audience).
+   *
+   * @example
+   * ```ts
+   * await sendcore.contacts.subscribe({
+   *   email: 'user@example.com',
+   *   firstName: 'John',
+   *   listId: 'lst_abc123',
+   * });
+   * ```
+   */
+  async subscribe(params) {
+    if (!params.email) {
+      throw new Error("SendCore: The 'email' field is required.");
+    }
+    return this.client._request("POST", "/organizations/audience/subscribe", params);
+  }
+  /**
+   * Unsubscribe a contact from your audience.
+   *
+   * @example
+   * ```ts
+   * await sendcore.contacts.unsubscribe({ email: 'user@example.com' });
+   * ```
+   */
+  async unsubscribe(params) {
+    if (!params.email) {
+      throw new Error("SendCore: The 'email' field is required.");
+    }
+    return this.client._request("POST", "/organizations/audience/unsubscribe", params);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SendCore,
+  SendCoreError
+});

package/dist/index.mjs

@@ -0,0 +1,185 @@
+// src/errors.ts
+var SendCoreError = class _SendCoreError extends Error {
+  statusCode;
+  detail;
+  constructor(statusCode, detail) {
+    const msg = detail.message || `SendCore API error (${statusCode})`;
+    super(msg);
+    this.name = "SendCoreError";
+    this.statusCode = statusCode;
+    this.detail = detail;
+    Object.setPrototypeOf(this, _SendCoreError.prototype);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.sendcore.elasto.ng";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRIES = 2;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var SDK_VERSION = "1.0.0";
+var SendCore = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  retries;
+  /** Email operations */
+  emails;
+  /** Audience / contact operations */
+  contacts;
+  constructor(apiKeyOrConfig) {
+    const config = typeof apiKeyOrConfig === "string" ? { apiKey: apiKeyOrConfig } : apiKeyOrConfig;
+    if (!config.apiKey) {
+      throw new Error(
+        "SendCore: An API key is required. Get one at https://sendcore.elasto.ng/dashboard/api-keys"
+      );
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.retries = config.retries ?? DEFAULT_RETRIES;
+    this.emails = new EmailsResource(this);
+    this.contacts = new ContactsResource(this);
+  }
+  // ─── Internal HTTP layer ────────────────────
+  /** @internal */
+  async _request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "x-api-key": this.apiKey,
+      "Content-Type": "application/json",
+      "User-Agent": `sendcore-node/${SDK_VERSION}`
+    };
+    const fetchOptions = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(this.timeout),
+      ...body ? { body: JSON.stringify(body) } : {}
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const response = await fetch(url, fetchOptions);
+        const responseBody = await response.json().catch(() => ({}));
+        if (response.ok) {
+          return responseBody;
+        }
+        if (!RETRYABLE_STATUS_CODES.has(response.status)) {
+          throw new SendCoreError(response.status, {
+            statusCode: response.status,
+            message: responseBody.message || response.statusText,
+            error: responseBody.error,
+            ...responseBody
+          });
+        }
+        lastError = new SendCoreError(response.status, {
+          statusCode: response.status,
+          message: responseBody.message || response.statusText,
+          error: responseBody.error,
+          ...responseBody
+        });
+      } catch (err) {
+        if (err instanceof SendCoreError) throw err;
+        lastError = err;
+      }
+      if (attempt < this.retries) {
+        const delay = Math.min(1e3 * 2 ** attempt, 1e4);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    throw lastError ?? new Error("SendCore: Request failed after retries");
+  }
+};
+var EmailsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Send an email.
+   *
+   * @example
+   * ```ts
+   * const result = await sendcore.emails.send({
+   *   from: 'hello@yourdomain.com',
+   *   to: 'user@example.com',
+   *   subject: 'Hello!',
+   *   html: '<h1>Welcome</h1>',
+   * });
+   * ```
+   */
+  async send(params) {
+    if (!params.from) {
+      throw new Error("SendCore: The 'from' field is required to send an email.");
+    }
+    if (!params.to) {
+      throw new Error("SendCore: The 'to' field is required to send an email.");
+    }
+    const payload = {
+      ...params,
+      to: Array.isArray(params.to) ? params.to : [params.to],
+      cc: params.cc ? Array.isArray(params.cc) ? params.cc : [params.cc] : void 0,
+      bcc: params.bcc ? Array.isArray(params.bcc) ? params.bcc : [params.bcc] : void 0,
+      replyTo: params.replyTo ? Array.isArray(params.replyTo) ? params.replyTo : [params.replyTo] : void 0
+    };
+    return this.client._request("POST", "/emails/send", payload);
+  }
+  /**
+   * Send an email using a pre-built template.
+   *
+   * @example
+   * ```ts
+   * await sendcore.emails.sendTemplate({
+   *   from: 'hello@yourdomain.com',
+   *   to: 'user@example.com',
+   *   templateId: 'welcome-email',
+   *   templateData: { name: 'John', plan: 'Pro' },
+   * });
+   * ```
+   */
+  async sendTemplate(params) {
+    return this.send(params);
+  }
+};
+var ContactsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Subscribe a contact (add to your audience).
+   *
+   * @example
+   * ```ts
+   * await sendcore.contacts.subscribe({
+   *   email: 'user@example.com',
+   *   firstName: 'John',
+   *   listId: 'lst_abc123',
+   * });
+   * ```
+   */
+  async subscribe(params) {
+    if (!params.email) {
+      throw new Error("SendCore: The 'email' field is required.");
+    }
+    return this.client._request("POST", "/organizations/audience/subscribe", params);
+  }
+  /**
+   * Unsubscribe a contact from your audience.
+   *
+   * @example
+   * ```ts
+   * await sendcore.contacts.unsubscribe({ email: 'user@example.com' });
+   * ```
+   */
+  async unsubscribe(params) {
+    if (!params.email) {
+      throw new Error("SendCore: The 'email' field is required.");
+    }
+    return this.client._request("POST", "/organizations/audience/unsubscribe", params);
+  }
+};
+export {
+  SendCore,
+  SendCoreError
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "sendcore",
+  "version": "1.0.0",
+  "description": "Official Node.js SDK for the SendCore email delivery platform",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "sendcore",
+    "email",
+    "smtp",
+    "transactional-email",
+    "email-api",
+    "broadcast",
+    "newsletter",
+    "elasto"
+  ],
+  "author": "Elasto Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/elastodev/sendcore-node"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  }
+}