emailr 0.2.0 → 1.0.1

package/dist/index.mjs

@@ -0,0 +1,666 @@
+// src/errors.ts
+var EmailrError = class _EmailrError extends Error {
+  constructor(message, statusCode, code, requestId) {
+    super(message);
+    this.name = "EmailrError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.requestId = requestId;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _EmailrError);
+    }
+  }
+};
+var NetworkError = class extends EmailrError {
+  constructor(message, cause) {
+    super(message, 0, "NETWORK_ERROR");
+    this.name = "NetworkError";
+    this.originalError = cause;
+  }
+};
+var AuthenticationError = class extends EmailrError {
+  constructor(message = "Invalid API key", requestId) {
+    super(message, 401, "AUTHENTICATION_ERROR", requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends EmailrError {
+  constructor(message = "Rate limit exceeded", retryAfter, requestId) {
+    super(message, 429, "RATE_LIMIT_ERROR", requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NotFoundError = class extends EmailrError {
+  constructor(message = "Resource not found", requestId) {
+    super(message, 404, "NOT_FOUND", requestId);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends EmailrError {
+  constructor(message, details, requestId) {
+    super(message, 400, "VALIDATION_ERROR", requestId);
+    this.name = "ValidationError";
+    this.details = details;
+  }
+};
+
+// src/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl;
+    this.timeout = config.timeout;
+  }
+  async get(path, options) {
+    return this.request("GET", path, void 0, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  async put(path, body, options) {
+    return this.request("PUT", path, body, options);
+  }
+  async patch(path, body, options) {
+    return this.request("PATCH", path, body, options);
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, void 0, options);
+  }
+  async request(method, path, body, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...options?.headers
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      if (!response.ok) {
+        await this.handleErrorResponse(response, requestId);
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof EmailrError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new NetworkError(`Request timeout after ${this.timeout}ms`);
+        }
+        throw new NetworkError(error.message, error);
+      }
+      throw new NetworkError("An unknown error occurred");
+    }
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  async handleErrorResponse(response, requestId) {
+    let errorData;
+    try {
+      errorData = await response.json();
+    } catch {
+      errorData = { error: response.statusText || "Unknown error" };
+    }
+    const message = errorData.error || "An error occurred";
+    switch (response.status) {
+      case 400:
+        throw new ValidationError(message, errorData.details, requestId);
+      case 401:
+        throw new AuthenticationError(message, requestId);
+      case 404:
+        throw new NotFoundError(message, requestId);
+      case 429:
+        const retryAfter = response.headers.get("retry-after");
+        throw new RateLimitError(
+          message,
+          retryAfter ? parseInt(retryAfter, 10) : void 0,
+          requestId
+        );
+      default:
+        throw new EmailrError(message, response.status, errorData.code, requestId);
+    }
+  }
+};
+
+// src/resources/emails.ts
+var EmailsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Send an email to one or multiple recipients
+   */
+  async send(data) {
+    return this.http.post("/v1/emails/send", data);
+  }
+  /**
+   * Get email by ID
+   */
+  async get(id) {
+    return this.http.get(`/v1/emails/${id}`);
+  }
+  /**
+   * List emails with pagination
+   */
+  async list(params) {
+    return this.http.get("/v1/emails", {
+      params
+    });
+  }
+  /**
+   * Forward an email to other recipients
+   */
+  async forward(data) {
+    return this.http.post("/v1/emails/forward", data);
+  }
+  /**
+   * Create an email forwarding rule
+   */
+  async createForwardingRule(data) {
+    return this.http.post("/v1/emails/forwarding-rules", data);
+  }
+  /**
+   * List all forwarding rules
+   */
+  async listForwardingRules() {
+    return this.http.get("/v1/emails/forwarding-rules");
+  }
+  /**
+   * Delete a forwarding rule
+   */
+  async deleteForwardingRule(id) {
+    return this.http.delete(`/v1/emails/forwarding-rules/${id}`);
+  }
+};
+
+// src/resources/contacts.ts
+var ContactsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new contact
+   */
+  async create(data) {
+    return this.http.post("/v1/contacts", data);
+  }
+  /**
+   * Get contact by ID
+   */
+  async get(id) {
+    return this.http.get(`/v1/contacts/${id}`);
+  }
+  /**
+   * List contacts with optional filtering
+   */
+  async list(params) {
+    return this.http.get("/v1/contacts", {
+      params
+    });
+  }
+  /**
+   * Update a contact
+   */
+  async update(id, data) {
+    return this.http.put(`/v1/contacts/${id}`, data);
+  }
+  /**
+   * Delete a contact
+   */
+  async delete(id) {
+    return this.http.delete(`/v1/contacts/${id}`);
+  }
+  /**
+   * Bulk create contacts
+   */
+  async bulkCreate(data) {
+    return this.http.post("/v1/contacts/bulk", data);
+  }
+  /**
+   * Unsubscribe a contact
+   */
+  async unsubscribe(id) {
+    return this.http.post(`/v1/contacts/${id}/unsubscribe`);
+  }
+  /**
+   * Resubscribe a contact
+   */
+  async resubscribe(id) {
+    return this.http.post(`/v1/contacts/${id}/resubscribe`);
+  }
+};
+
+// src/resources/templates.ts
+var TemplatesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new template
+   */
+  async create(data) {
+    return this.http.post("/v1/templates", data);
+  }
+  /**
+   * Get template by ID
+   */
+  async get(id) {
+    return this.http.get(`/v1/templates/${id}`);
+  }
+  /**
+   * List templates with pagination
+   */
+  async list(params) {
+    return this.http.get("/v1/templates", {
+      params
+    });
+  }
+  /**
+   * Update a template
+   */
+  async update(id, data) {
+    return this.http.put(`/v1/templates/${id}`, data);
+  }
+  /**
+   * Delete a template
+   */
+  async delete(id) {
+    return this.http.delete(`/v1/templates/${id}`);
+  }
+  /**
+   * Duplicate a template
+   */
+  async duplicate(id) {
+    return this.http.post(`/v1/templates/${id}/duplicate`);
+  }
+};
+
+// src/resources/domains.ts
+var DomainsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Add a new domain
+   */
+  async add(data) {
+    return this.http.post("/v1/domains", data);
+  }
+  /**
+   * Get domain by ID
+   */
+  async get(id) {
+    return this.http.get(`/v1/domains/${id}`);
+  }
+  /**
+   * List all domains
+   */
+  async list() {
+    return this.http.get("/v1/domains");
+  }
+  /**
+   * Update domain settings
+   */
+  async update(id, data) {
+    return this.http.patch(`/v1/domains/${id}`, data);
+  }
+  /**
+   * Delete a domain
+   */
+  async delete(id) {
+    return this.http.delete(`/v1/domains/${id}`);
+  }
+  /**
+   * Verify domain DNS records
+   */
+  async verify(id) {
+    return this.http.post(`/v1/domains/${id}/verify`);
+  }
+  /**
+   * Check DNS verification status
+   */
+  async checkDns(id) {
+    return this.http.get(`/v1/domains/${id}/dns-status`);
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new webhook
+   */
+  async create(data) {
+    return this.http.post("/v1/webhooks", data);
+  }
+  /**
+   * Get webhook by ID
+   */
+  async get(id) {
+    return this.http.get(`/v1/webhooks/${id}`);
+  }
+  /**
+   * List webhooks with pagination
+   */
+  async list(params) {
+    return this.http.get("/v1/webhooks", {
+      params
+    });
+  }
+  /**
+   * Update a webhook
+   */
+  async update(id, data) {
+    return this.http.put(`/v1/webhooks/${id}`, data);
+  }
+  /**
+   * Delete a webhook
+   */
+  async delete(id) {
+    return this.http.delete(`/v1/webhooks/${id}`);
+  }
+  /**
+   * Enable a webhook
+   */
+  async enable(id) {
+    return this.http.post(`/v1/webhooks/${id}/enable`);
+  }
+  /**
+   * Disable a webhook
+   */
+  async disable(id) {
+    return this.http.post(`/v1/webhooks/${id}/disable`);
+  }
+  /**
+   * List webhook deliveries
+   */
+  async listDeliveries(id) {
+    return this.http.get(`/v1/webhooks/${id}/deliveries`);
+  }
+  /**
+   * Retry a failed webhook delivery
+   */
+  async retryDelivery(webhookId, deliveryId) {
+    return this.http.post(`/v1/webhooks/${webhookId}/deliveries/${deliveryId}/retry`);
+  }
+};
+
+// src/resources/broadcasts.ts
+var BroadcastsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new broadcast
+   */
+  async create(data) {
+    return this.http.post("/v1/broadcasts", data);
+  }
+  /**
+   * Get broadcast by ID
+   */
+  async get(id) {
+    return this.http.get(`/v1/broadcasts/${id}`);
+  }
+  /**
+   * List broadcasts
+   */
+  async list(params) {
+    const queryParams = {};
+    if (params?.page) queryParams.page = String(params.page);
+    if (params?.limit) queryParams.limit = String(params.limit);
+    if (params?.status) queryParams.status = params.status;
+    const data = await this.http.get("/v1/broadcasts", queryParams);
+    if (Array.isArray(data)) {
+      return data;
+    }
+    return data.data || [];
+  }
+  /**
+   * Update a broadcast
+   */
+  async update(id, data) {
+    return this.http.put(`/v1/broadcasts/${id}`, data);
+  }
+  /**
+   * Delete a broadcast
+   */
+  async delete(id) {
+    return this.http.delete(`/v1/broadcasts/${id}`);
+  }
+  /**
+   * Send a broadcast immediately
+   */
+  async send(id) {
+    return this.http.post(`/v1/broadcasts/${id}/send`);
+  }
+  /**
+   * Schedule a broadcast
+   */
+  async schedule(id, scheduledAt) {
+    return this.http.post(`/v1/broadcasts/${id}/schedule`, { scheduled_at: scheduledAt });
+  }
+  /**
+   * Cancel a scheduled broadcast
+   */
+  async cancel(id) {
+    return this.http.post(`/v1/broadcasts/${id}/cancel`);
+  }
+  /**
+   * Get broadcast statistics
+   */
+  async getStats(id) {
+    return this.http.get(`/v1/broadcasts/${id}/stats`);
+  }
+};
+
+// src/resources/segments.ts
+var SegmentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new segment
+   */
+  async create(data) {
+    return this.http.post("/v1/segments", data);
+  }
+  /**
+   * Get segment by ID
+   */
+  async get(id) {
+    return this.http.get(`/v1/segments/${id}`);
+  }
+  /**
+   * List segments with pagination
+   */
+  async list(params) {
+    return this.http.get("/v1/segments", {
+      params
+    });
+  }
+  /**
+   * Update a segment
+   */
+  async update(id, data) {
+    return this.http.put(`/v1/segments/${id}`, data);
+  }
+  /**
+   * Delete a segment
+   */
+  async delete(id) {
+    return this.http.delete(`/v1/segments/${id}`);
+  }
+  /**
+   * Get contacts in a segment
+   */
+  async getContacts(id, params) {
+    return this.http.get(`/v1/segments/${id}/contacts`, {
+      params
+    });
+  }
+  /**
+   * Get segment contact count
+   */
+  async getCount(id) {
+    return this.http.get(`/v1/segments/${id}/count`);
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new API key.
+   * Note: The full key is only returned once upon creation.
+   */
+  async create(data) {
+    return this.http.post("/v1/api-keys", data);
+  }
+  /**
+   * List all active API keys.
+   * Note: Full keys are not returned for security.
+   */
+  async list() {
+    return this.http.get("/v1/api-keys");
+  }
+  /**
+   * Revoke an API key.
+   */
+  async revoke(id) {
+    return this.http.delete(`/v1/api-keys/${id}`);
+  }
+};
+
+// src/resources/smtp.ts
+var SmtpResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get SMTP credentials for sending emails.
+   * The password is your API key.
+   */
+  async getCredentials() {
+    return this.http.get("/v1/smtp/credentials");
+  }
+};
+
+// src/resources/settings.ts
+var SettingsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get organization settings.
+   */
+  async getOrganization() {
+    return this.http.get("/v1/settings/organization");
+  }
+  /**
+   * Update organization settings.
+   */
+  async updateOrganization(data) {
+    return this.http.put("/v1/settings/organization", data);
+  }
+  /**
+   * Get team members.
+   */
+  async getTeam() {
+    return this.http.get("/v1/settings/team");
+  }
+  /**
+   * Get unsubscribe settings.
+   */
+  async getUnsubscribeSettings() {
+    return this.http.get("/v1/settings/unsubscribe");
+  }
+  /**
+   * Update unsubscribe settings.
+   */
+  async updateUnsubscribeSettings(data) {
+    return this.http.put("/v1/settings/unsubscribe", data);
+  }
+};
+
+// src/resources/metrics.ts
+var MetricsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get usage metrics for a specified number of days.
+   */
+  async getUsage(days = 30) {
+    return this.http.get("/v1/metrics/usage", { params: { days } });
+  }
+  /**
+   * Get aggregated email delivery metrics.
+   */
+  async getEmailMetrics() {
+    return this.http.get("/v1/metrics/emails");
+  }
+};
+
+// src/client.ts
+var Emailr = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    this.http = new HttpClient({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? "https://api.emailr.dev",
+      timeout: config.timeout ?? 3e4
+    });
+    this.emails = new EmailsResource(this.http);
+    this.contacts = new ContactsResource(this.http);
+    this.templates = new TemplatesResource(this.http);
+    this.domains = new DomainsResource(this.http);
+    this.webhooks = new WebhooksResource(this.http);
+    this.broadcasts = new BroadcastsResource(this.http);
+    this.segments = new SegmentsResource(this.http);
+    this.apiKeys = new ApiKeysResource(this.http);
+    this.smtp = new SmtpResource(this.http);
+    this.settings = new SettingsResource(this.http);
+    this.metrics = new MetricsResource(this.http);
+  }
+};
+export {
+  AuthenticationError,
+  Emailr,
+  Emailr as EmailrClient,
+  EmailrError,
+  NetworkError,
+  NotFoundError,
+  RateLimitError,
+  ValidationError
+};