mailerbot 0.1.0

package/dist/index.js

@@ -0,0 +1,842 @@
+// src/errors.ts
+var MailerBotError = class extends Error {
+  statusCode;
+  response;
+  constructor(message, options) {
+    super(message);
+    this.name = "MailerBotError";
+    this.statusCode = options?.statusCode;
+    this.response = options?.response;
+  }
+};
+var AuthenticationError = class extends MailerBotError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionError = class extends MailerBotError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends MailerBotError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends MailerBotError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends MailerBotError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RateLimitError";
+  }
+};
+var ServerError = class extends MailerBotError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ServerError";
+  }
+};
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://api.mailerbot.com/api/v1";
+var DEFAULT_TIMEOUT = 3e4;
+function buildHeaders(apiKey) {
+  return {
+    "X-API-Key": apiKey,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+}
+async function raiseForStatus(response) {
+  if (response.ok) return;
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = { detail: await response.text().catch(() => "Unknown error") };
+  }
+  const detail = typeof body.detail === "string" ? body.detail : JSON.stringify(body);
+  const status = response.status;
+  const opts = { statusCode: status, response: body };
+  if (status === 401) throw new AuthenticationError(detail, opts);
+  if (status === 403) throw new PermissionError(detail, opts);
+  if (status === 404) throw new NotFoundError(detail, opts);
+  if (status === 422) throw new ValidationError(detail, opts);
+  if (status === 429) throw new RateLimitError(detail, opts);
+  if (status >= 500) throw new ServerError(detail, opts);
+  throw new MailerBotError(detail, opts);
+}
+var HttpClient = class {
+  baseUrl;
+  headers;
+  timeout;
+  constructor(baseUrl, headers, timeout) {
+    this.baseUrl = baseUrl;
+    this.headers = headers;
+    this.timeout = timeout;
+  }
+  async request(options) {
+    const fullUrl = `${this.baseUrl}${options.path.startsWith("/") ? "" : "/"}${options.path}`;
+    const urlObj = new URL(fullUrl);
+    if (options.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0) {
+          urlObj.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const mergedHeaders = { ...this.headers, ...options.headers };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(urlObj.toString(), {
+        method: options.method ?? "GET",
+        headers: mergedHeaders,
+        body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      await raiseForStatus(response);
+      const text = await response.text();
+      if (!text) return void 0;
+      return JSON.parse(text);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async requestRaw(options) {
+    const fullUrl = `${this.baseUrl}${options.path.startsWith("/") ? "" : "/"}${options.path}`;
+    const urlObj = new URL(fullUrl);
+    if (options.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0) {
+          urlObj.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(urlObj.toString(), {
+        method: options.method ?? "POST",
+        headers: options.rawHeaders ?? this.headers,
+        body: options.rawBody,
+        signal: controller.signal
+      });
+      await raiseForStatus(response);
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// src/pagination.ts
+var PageIterator = class {
+  fetch;
+  pageSize;
+  constructor(fetch2, pageSize = 100) {
+    this.fetch = fetch2;
+    this.pageSize = pageSize;
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = 1;
+    while (true) {
+      const result = await this.fetch(page, this.pageSize);
+      for (const item of result.items) {
+        yield item;
+      }
+      if (page >= result.pages) break;
+      page++;
+    }
+  }
+};
+
+// src/resources/contacts.ts
+var ContactsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(options) {
+    return this.http.request({
+      path: "/contacts",
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50,
+        search: options?.search
+      }
+    });
+  }
+  iterAll(options) {
+    return new PageIterator(
+      (page, pageSize) => this.list({ page, pageSize, search: options?.search }),
+      options?.pageSize ?? 100
+    );
+  }
+  async get(contactId) {
+    return this.http.request({ path: `/contacts/${contactId}` });
+  }
+  async create(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/contacts",
+      body: params
+    });
+  }
+  async update(contactId, params) {
+    return this.http.request({
+      method: "PUT",
+      path: `/contacts/${contactId}`,
+      body: params
+    });
+  }
+  async delete(contactId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/contacts/${contactId}`
+    });
+  }
+  async importCsv(contacts, options) {
+    return this.http.request({
+      method: "POST",
+      path: "/contacts/import",
+      body: { contacts, listName: options?.listName }
+    });
+  }
+  async validateAddresses(contactIds) {
+    return this.http.request({
+      method: "POST",
+      path: "/contacts/validate",
+      body: { contactIds }
+    });
+  }
+};
+
+// src/resources/contact-lists.ts
+var ContactListsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    return this.http.request({ path: "/contact-lists" });
+  }
+  async get(listId) {
+    return this.http.request({
+      path: `/contact-lists/${listId}`
+    });
+  }
+  async create(name, options) {
+    return this.http.request({
+      method: "POST",
+      path: "/contact-lists",
+      body: { name, contactIds: options?.contactIds ?? [] }
+    });
+  }
+  async update(listId, name) {
+    return this.http.request({
+      method: "PUT",
+      path: `/contact-lists/${listId}`,
+      body: { name }
+    });
+  }
+  async delete(listId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/contact-lists/${listId}`
+    });
+  }
+  async addContacts(listId, contactIds) {
+    await this.http.request({
+      method: "POST",
+      path: `/contact-lists/${listId}/contacts`,
+      body: { contactIds }
+    });
+  }
+  async removeContacts(listId, contactIds) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/contact-lists/${listId}/contacts`,
+      body: { contactIds }
+    });
+  }
+};
+
+// src/resources/documents.ts
+var DocumentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(options) {
+    return this.http.request({
+      path: "/documents",
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50,
+        type: options?.type
+      }
+    });
+  }
+  iterAll(options) {
+    return new PageIterator(
+      (page, pageSize) => this.list({ page, pageSize }),
+      options?.pageSize ?? 100
+    );
+  }
+  async get(documentId) {
+    return this.http.request({ path: `/documents/${documentId}` });
+  }
+  async create(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/documents",
+      body: {
+        title: params?.title ?? "Untitled Document",
+        content: params?.content ?? ""
+      }
+    });
+  }
+  async update(documentId, params) {
+    return this.http.request({
+      method: "PUT",
+      path: `/documents/${documentId}`,
+      body: params
+    });
+  }
+  async delete(documentId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/documents/${documentId}`
+    });
+  }
+  async upload(file, filename) {
+    const formData = new FormData();
+    const blob = file instanceof Blob ? file : new Blob([file], { type: "application/pdf" });
+    formData.append("file", blob, filename);
+    const response = await this.http.requestRaw({
+      method: "POST",
+      path: "/documents/upload",
+      rawBody: formData,
+      rawHeaders: {}
+      // let fetch set Content-Type with boundary
+    });
+    return await response.json();
+  }
+};
+
+// src/resources/postcards.ts
+var PostcardsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async listTemplates() {
+    return this.http.request({
+      path: "/postcards/templates"
+    });
+  }
+  async getTemplate(templateId) {
+    return this.http.request({
+      path: `/postcards/templates/${templateId}`
+    });
+  }
+  async list(options) {
+    return this.http.request({
+      path: "/postcards",
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50
+      }
+    });
+  }
+  iterAll(options) {
+    return new PageIterator(
+      (page, pageSize) => this.list({ page, pageSize }),
+      options?.pageSize ?? 100
+    );
+  }
+  async get(postcardId) {
+    return this.http.request({ path: `/postcards/${postcardId}` });
+  }
+  async create(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/postcards",
+      body: {
+        title: params?.title ?? "Untitled Postcard",
+        front: params?.front,
+        back: params?.back
+      }
+    });
+  }
+  async update(postcardId, params) {
+    return this.http.request({
+      method: "PUT",
+      path: `/postcards/${postcardId}`,
+      body: params
+    });
+  }
+  async delete(postcardId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/postcards/${postcardId}`
+    });
+  }
+};
+
+// src/resources/mailings.ts
+function toISOString(date) {
+  if (date === void 0) return void 0;
+  return date instanceof Date ? date.toISOString() : date;
+}
+var MailingsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(options) {
+    return this.http.request({
+      path: "/mailings",
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50
+      }
+    });
+  }
+  iterAll(options) {
+    return new PageIterator(
+      (page, pageSize) => this.list({ page, pageSize }),
+      options?.pageSize ?? 100
+    );
+  }
+  async get(mailingId) {
+    return this.http.request({ path: `/mailings/${mailingId}` });
+  }
+  async create(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/mailings",
+      body: {
+        name: params.name,
+        type: params.type,
+        contactListId: params.contactListId,
+        documentId: params.documentId,
+        postcardId: params.postcardId,
+        couponListId: params.couponListId,
+        scheduledDate: toISOString(params.scheduledDate),
+        printColor: params.printColor ?? false,
+        postageSelections: params.postageSelections
+      }
+    });
+  }
+  async update(mailingId, params) {
+    return this.http.request({
+      method: "PUT",
+      path: `/mailings/${mailingId}`,
+      body: {
+        name: params.name,
+        scheduledDate: toISOString(params.scheduledDate)
+      }
+    });
+  }
+  async delete(mailingId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/mailings/${mailingId}`
+    });
+  }
+  async validateAddresses(mailingId) {
+    return this.http.request({
+      method: "POST",
+      path: `/mailings/${mailingId}/validate-addresses`
+    });
+  }
+  async estimateCost(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/mailings/estimate-cost",
+      body: {
+        type: params.type,
+        contactListId: params.contactListId,
+        contactIds: params.contactIds,
+        documentId: params.documentId,
+        printColor: params.printColor ?? false
+      }
+    });
+  }
+  async calculateCost(mailingId) {
+    return this.http.request({
+      method: "POST",
+      path: `/mailings/${mailingId}/calculate-cost`
+    });
+  }
+  async send(mailingId) {
+    return this.http.request({
+      method: "POST",
+      path: `/mailings/${mailingId}/send`
+    });
+  }
+  async listItems(mailingId, options) {
+    return this.http.request({
+      path: `/mailings/${mailingId}/items`,
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50,
+        trackingStatus: options?.trackingStatus
+      }
+    });
+  }
+  iterItems(mailingId, options) {
+    return new PageIterator(
+      (page, pageSize) => this.listItems(mailingId, {
+        page,
+        pageSize,
+        trackingStatus: options?.trackingStatus
+      }),
+      options?.pageSize ?? 100
+    );
+  }
+  async listItemScans(mailingId, itemId) {
+    return this.http.request({
+      path: `/mailings/${mailingId}/items/${itemId}/scans`
+    });
+  }
+};
+
+// src/resources/campaigns.ts
+var CampaignsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(options) {
+    return this.http.request({
+      path: "/campaigns",
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50
+      }
+    });
+  }
+  iterAll(options) {
+    return new PageIterator(
+      (page, pageSize) => this.list({ page, pageSize }),
+      options?.pageSize ?? 100
+    );
+  }
+  async get(campaignId) {
+    return this.http.request({ path: `/campaigns/${campaignId}` });
+  }
+  async create(name, options) {
+    return this.http.request({
+      method: "POST",
+      path: "/campaigns",
+      body: { name, mailingIds: options?.mailingIds ?? [] }
+    });
+  }
+  async update(campaignId, params) {
+    return this.http.request({
+      method: "PUT",
+      path: `/campaigns/${campaignId}`,
+      body: params
+    });
+  }
+  async delete(campaignId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/campaigns/${campaignId}`
+    });
+  }
+  async addMailing(campaignId, mailingId) {
+    return this.http.request({
+      method: "POST",
+      path: `/campaigns/${campaignId}/mailings`,
+      body: { mailing_id: mailingId }
+    });
+  }
+  async removeMailing(campaignId, mailingId) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/campaigns/${campaignId}/mailings/${mailingId}`
+    });
+  }
+};
+
+// src/resources/dashboard.ts
+var DashboardResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async stats() {
+    return this.http.request({ path: "/dashboard/stats" });
+  }
+  async reporting(options) {
+    return this.http.request({
+      path: "/dashboard/reporting",
+      params: {
+        start_date: options?.startDate,
+        end_date: options?.endDate
+      }
+    });
+  }
+};
+
+// src/resources/payments.ts
+var PaymentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async createPaymentIntent(mailingId, options) {
+    const body = { mailingId };
+    if (options?.paymentMethodId) {
+      body.paymentMethodId = options.paymentMethodId;
+    }
+    return this.http.request({
+      method: "POST",
+      path: "/payments/create-payment-intent",
+      body
+    });
+  }
+  async getStripeKey() {
+    const data = await this.http.request({
+      path: "/payments/config"
+    });
+    return data.publishable_key;
+  }
+  async listCards() {
+    return this.http.request({ path: "/payments/cards" });
+  }
+  async deleteCard(paymentMethodId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/payments/cards/${paymentMethodId}`
+    });
+  }
+};
+
+// src/resources/qr.ts
+var QrResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(options) {
+    return this.http.request({
+      path: "/qr/links",
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50
+      }
+    });
+  }
+  iterAll(options) {
+    return new PageIterator(
+      (page, pageSize) => this.list({ page, pageSize }),
+      options?.pageSize ?? 100
+    );
+  }
+  async create(params) {
+    return this.http.request({
+      method: "POST",
+      path: "/qr/links",
+      body: params
+    });
+  }
+  async delete(linkId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/qr/links/${linkId}`
+    });
+  }
+  async analytics(options) {
+    return this.http.request({
+      path: "/qr/analytics",
+      params: { days: options?.days ?? 30 }
+    });
+  }
+};
+
+// src/resources/merge-tags.ts
+var MergeTagsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    return this.http.request({ path: "/merge-tags" });
+  }
+};
+
+// src/resources/pricing.ts
+var PricingResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async catalog() {
+    return this.http.request({ path: "/pricing" });
+  }
+  async countries() {
+    return this.http.request({
+      path: "/pricing/countries"
+    });
+  }
+  async postageZones() {
+    return this.http.request({
+      path: "/pricing/postage-zones"
+    });
+  }
+  async postageRates(options) {
+    return this.http.request({
+      path: "/pricing/postage-rates",
+      params: {
+        product_type: options?.productType,
+        zone: options?.zone
+      }
+    });
+  }
+};
+
+// src/resources/coupons.ts
+var CouponsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    return this.http.request({ path: "/coupons" });
+  }
+  async get(listId) {
+    return this.http.request({ path: `/coupons/${listId}` });
+  }
+  async create(name, options) {
+    return this.http.request({
+      method: "POST",
+      path: "/coupons",
+      body: { name, description: options?.description }
+    });
+  }
+  async update(listId, params) {
+    return this.http.request({
+      method: "PUT",
+      path: `/coupons/${listId}`,
+      body: params
+    });
+  }
+  async delete(listId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/coupons/${listId}`
+    });
+  }
+  async listCodes(listId, options) {
+    return this.http.request({
+      path: `/coupons/${listId}/codes`,
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50,
+        used: options?.used
+      }
+    });
+  }
+  async importCodes(listId, codes) {
+    return this.http.request({
+      method: "POST",
+      path: `/coupons/${listId}/codes/import`,
+      body: { codes }
+    });
+  }
+  async deleteCode(listId, codeId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/coupons/${listId}/codes/${codeId}`
+    });
+  }
+  async checkAvailability(listId, count) {
+    return this.http.request({
+      path: `/coupons/${listId}/availability`,
+      params: { count }
+    });
+  }
+};
+
+// src/resources/assets.ts
+var AssetsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(options) {
+    return this.http.request({
+      path: "/assets",
+      params: {
+        page: options?.page ?? 1,
+        page_size: options?.pageSize ?? 50
+      }
+    });
+  }
+  iterAll(options) {
+    return new PageIterator(
+      (page, pageSize) => this.list({ page, pageSize }),
+      options?.pageSize ?? 100
+    );
+  }
+  async upload(file, filename, mimeType) {
+    const formData = new FormData();
+    const blob = file instanceof Blob ? file : new Blob([file], { type: mimeType ?? "application/octet-stream" });
+    formData.append("file", blob, filename);
+    const response = await this.http.requestRaw({
+      method: "POST",
+      path: "/assets",
+      rawBody: formData,
+      rawHeaders: {}
+      // let fetch set Content-Type with boundary
+    });
+    return await response.json();
+  }
+  async delete(assetId) {
+    await this.http.request({
+      method: "DELETE",
+      path: `/assets/${assetId}`
+    });
+  }
+};
+
+// src/client.ts
+var MailerBot = class {
+  contacts;
+  contactLists;
+  documents;
+  postcards;
+  mailings;
+  campaigns;
+  dashboard;
+  payments;
+  qr;
+  mergeTags;
+  pricing;
+  coupons;
+  assets;
+  constructor(apiKey, options) {
+    const baseUrl = (options?.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+    const headers = buildHeaders(apiKey);
+    const http = new HttpClient(baseUrl, headers, timeout);
+    this.contacts = new ContactsResource(http);
+    this.contactLists = new ContactListsResource(http);
+    this.documents = new DocumentsResource(http);
+    this.postcards = new PostcardsResource(http);
+    this.mailings = new MailingsResource(http);
+    this.campaigns = new CampaignsResource(http);
+    this.dashboard = new DashboardResource(http);
+    this.payments = new PaymentsResource(http);
+    this.qr = new QrResource(http);
+    this.mergeTags = new MergeTagsResource(http);
+    this.pricing = new PricingResource(http);
+    this.coupons = new CouponsResource(http);
+    this.assets = new AssetsResource(http);
+  }
+};
+
+export { AuthenticationError, MailerBot, MailerBotError, NotFoundError, PageIterator, PermissionError, RateLimitError, ServerError, ValidationError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map