migma 1.0.0

package/dist/index.js

@@ -0,0 +1,812 @@
+'use strict';
+
+// src/errors.ts
+var MigmaErrorCode = /* @__PURE__ */ ((MigmaErrorCode2) => {
+  MigmaErrorCode2["VALIDATION_ERROR"] = "validation_error";
+  MigmaErrorCode2["NOT_FOUND"] = "not_found";
+  MigmaErrorCode2["UNAUTHORIZED"] = "unauthorized";
+  MigmaErrorCode2["FORBIDDEN"] = "forbidden";
+  MigmaErrorCode2["RATE_LIMIT_EXCEEDED"] = "rate_limit_exceeded";
+  MigmaErrorCode2["CONFLICT"] = "conflict";
+  MigmaErrorCode2["TIMEOUT"] = "timeout";
+  MigmaErrorCode2["NETWORK_ERROR"] = "network_error";
+  MigmaErrorCode2["INTERNAL_ERROR"] = "internal_error";
+  MigmaErrorCode2["UNKNOWN"] = "unknown";
+  return MigmaErrorCode2;
+})(MigmaErrorCode || {});
+var MigmaError = class _MigmaError extends Error {
+  statusCode;
+  code;
+  constructor(message, statusCode, code) {
+    super(message);
+    this.name = "MigmaError";
+    this.statusCode = statusCode;
+    this.code = code ?? _MigmaError.codeFromStatus(statusCode);
+  }
+  static codeFromStatus(status) {
+    switch (status) {
+      case 400:
+        return "validation_error" /* VALIDATION_ERROR */;
+      case 401:
+        return "unauthorized" /* UNAUTHORIZED */;
+      case 403:
+        return "forbidden" /* FORBIDDEN */;
+      case 404:
+        return "not_found" /* NOT_FOUND */;
+      case 409:
+        return "conflict" /* CONFLICT */;
+      case 429:
+        return "rate_limit_exceeded" /* RATE_LIMIT_EXCEEDED */;
+      default:
+        if (status >= 500) return "internal_error" /* INTERNAL_ERROR */;
+        return "unknown" /* UNKNOWN */;
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      code: this.code
+    };
+  }
+};
+
+// src/client.ts
+var MigmaClient = class {
+  apiKey;
+  config;
+  constructor(apiKey, config) {
+    this.apiKey = apiKey;
+    this.config = config;
+  }
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const timeout = options.timeout ?? this.config.timeout;
+    const attempts = this.config.maxRetries + 1;
+    let lastError = null;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(url, {
+          method: options.method,
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            "User-Agent": "migma-node/1.0.0"
+          },
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const json = await response.json();
+        if (!response.ok || !json.success) {
+          const error = new MigmaError(
+            json.error || `Request failed with status ${response.status}`,
+            response.status
+          );
+          if (response.status >= 500 || response.status === 429) {
+            lastError = error;
+            if (attempt < attempts - 1) {
+              const delay = response.status === 429 ? this.parseRetryAfter(response) ?? this.config.retryDelay * (attempt + 1) : this.config.retryDelay * Math.pow(2, attempt);
+              await this.sleep(delay);
+              continue;
+            }
+          }
+          return { data: null, error };
+        }
+        return { data: json.data, error: null };
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof Error && err.name === "AbortError") {
+          return {
+            data: null,
+            error: new MigmaError(
+              "Request timed out",
+              0,
+              "timeout" /* TIMEOUT */
+            )
+          };
+        }
+        lastError = new MigmaError(
+          err instanceof Error ? err.message : "Network error",
+          0,
+          "network_error" /* NETWORK_ERROR */
+        );
+        if (attempt < attempts - 1) {
+          await this.sleep(this.config.retryDelay * Math.pow(2, attempt));
+          continue;
+        }
+      }
+    }
+    return { data: null, error: lastError };
+  }
+  /**
+   * For endpoints where the API returns `{ success, data, count }` and we want
+   * both the data array and the count together.
+   */
+  async requestWithCount(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const timeout = options.timeout ?? this.config.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": "migma-node/1.0.0"
+        },
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const json = await response.json();
+      if (!response.ok || !json.success) {
+        return {
+          data: null,
+          error: new MigmaError(
+            json.error || `Request failed with status ${response.status}`,
+            response.status
+          )
+        };
+      }
+      return {
+        data: { data: json.data, count: json.count ?? 0 },
+        error: null
+      };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error && err.name === "AbortError") {
+        return {
+          data: null,
+          error: new MigmaError(
+            "Request timed out",
+            0,
+            "timeout" /* TIMEOUT */
+          )
+        };
+      }
+      return {
+        data: null,
+        error: new MigmaError(
+          err instanceof Error ? err.message : "Network error",
+          0,
+          "network_error" /* NETWORK_ERROR */
+        )
+      };
+    }
+  }
+  async get(path, query) {
+    return this.request({ method: "GET", path, query });
+  }
+  async getWithCount(path, query) {
+    return this.requestWithCount({ method: "GET", path, query });
+  }
+  async post(path, body) {
+    return this.request({ method: "POST", path, body });
+  }
+  async patch(path, body) {
+    return this.request({ method: "PATCH", path, body });
+  }
+  async put(path, body) {
+    return this.request({ method: "PUT", path, body });
+  }
+  async delete(path, query) {
+    return this.request({ method: "DELETE", path, query });
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.config.baseUrl}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  parseRetryAfter(response) {
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+      const seconds = parseInt(retryAfter, 10);
+      if (!isNaN(seconds)) return seconds * 1e3;
+    }
+    return null;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/resources/contacts.ts
+var Contacts = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    return this.client.post("/contacts", params);
+  }
+  async list(params) {
+    const { projectId, page, limit, tags, status, search } = params;
+    return this.client.getWithCount("/contacts", {
+      projectId,
+      page,
+      limit,
+      tags,
+      status,
+      search
+    });
+  }
+  async get(id, projectId) {
+    return this.client.get(`/contacts/${id}`, { projectId });
+  }
+  async update(id, params) {
+    return this.client.patch(`/contacts/${id}`, params);
+  }
+  async remove(id, projectId) {
+    return this.client.delete(`/contacts/${id}`, { projectId });
+  }
+  async bulkImport(params) {
+    return this.client.post("/contacts/bulk", params);
+  }
+  async getBulkImportStatus(jobId) {
+    return this.client.get(`/contacts/bulk/${jobId}`);
+  }
+  async changeStatus(params) {
+    return this.client.post("/contacts/status", params);
+  }
+};
+
+// src/resources/tags.ts
+var Tags = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    const { projectId, page, limit, search, sortBy, sortOrder } = params;
+    return this.client.getWithCount("/tags", {
+      projectId,
+      page,
+      limit,
+      search,
+      sortBy,
+      sortOrder
+    });
+  }
+  async create(params) {
+    return this.client.post("/tags", params);
+  }
+  async get(id, projectId) {
+    return this.client.get(`/tags/${id}`, { projectId });
+  }
+  async update(id, params) {
+    return this.client.patch(`/tags/${id}`, params);
+  }
+  async remove(id, projectId) {
+    return this.client.delete(`/tags/${id}`, { projectId });
+  }
+};
+
+// src/resources/segments.ts
+var Segments = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(projectId) {
+    return this.client.getWithCount("/segments", {
+      projectId
+    });
+  }
+  async create(params) {
+    return this.client.post("/segments", params);
+  }
+  async get(id, projectId) {
+    return this.client.get(`/segments/${id}`, { projectId });
+  }
+  async update(id, params) {
+    return this.client.patch(`/segments/${id}`, params);
+  }
+  async remove(id, projectId) {
+    return this.client.delete(`/segments/${id}`, { projectId });
+  }
+};
+
+// src/resources/topics.ts
+var Topics = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    const { projectId, includeInactive } = params;
+    return this.client.getWithCount("/topics", {
+      projectId,
+      includeInactive
+    });
+  }
+  async create(params) {
+    return this.client.post("/topics", params);
+  }
+  async get(id, projectId) {
+    return this.client.get(`/topics/${id}`, { projectId });
+  }
+  async update(id, params) {
+    return this.client.patch(`/topics/${id}`, params);
+  }
+  async remove(id, projectId) {
+    return this.client.delete(`/topics/${id}`, { projectId });
+  }
+  async subscribe(topicId, params) {
+    return this.client.post(
+      `/topics/${topicId}/subscribe`,
+      params
+    );
+  }
+  async unsubscribe(topicId, params) {
+    return this.client.post(
+      `/topics/${topicId}/unsubscribe`,
+      params
+    );
+  }
+};
+
+// src/resources/sending.ts
+var Sending = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async send(params) {
+    return this.client.post("/sending", params);
+  }
+  async getBatchStatus(batchId) {
+    return this.client.get(`/sending/batches/${batchId}`);
+  }
+};
+
+// src/polling.ts
+async function poll(fetcher, isComplete, options) {
+  const interval = options?.interval ?? 2e3;
+  const maxAttempts = options?.maxAttempts ?? 150;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (options?.signal?.aborted) {
+      return {
+        data: null,
+        error: new MigmaError("Polling aborted", 0, "timeout" /* TIMEOUT */)
+      };
+    }
+    const result = await fetcher();
+    if (result.error) {
+      return result;
+    }
+    options?.onPoll?.(result.data, attempt);
+    if (isComplete(result.data)) {
+      return result;
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, interval);
+      if (options?.signal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          resolve();
+        };
+        options.signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+  }
+  return {
+    data: null,
+    error: new MigmaError(
+      "Polling timed out after maximum attempts",
+      0,
+      "timeout" /* TIMEOUT */
+    )
+  };
+}
+
+// src/resources/projects.ts
+var Projects = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get("/projects", {
+      limit: params?.limit,
+      offset: params?.offset,
+      status: params?.status
+    });
+  }
+  async get(projectId) {
+    return this.client.get(`/projects/${projectId}`);
+  }
+  async import(params) {
+    return this.client.post(
+      "/projects/import",
+      params
+    );
+  }
+  async getImportStatus(projectId) {
+    return this.client.get(
+      `/projects/import/${projectId}/status`
+    );
+  }
+  async retryImport(projectId) {
+    return this.client.post(
+      `/projects/import/${projectId}/retry`
+    );
+  }
+  /**
+   * Import a project and wait for completion.
+   * Polls getImportStatus until status is 'active' or 'error'.
+   */
+  async importAndWait(params, options) {
+    const startResult = await this.import(params);
+    if (startResult.error) {
+      return { data: null, error: startResult.error };
+    }
+    const projectId = startResult.data.projectId;
+    return poll(
+      () => this.getImportStatus(projectId),
+      (status) => status.status === "active" || status.status === "error",
+      options
+    );
+  }
+};
+
+// src/resources/emails.ts
+var Emails = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Start async email generation */
+  async generate(params) {
+    return this.client.post(
+      "/projects/emails/generate",
+      params
+    );
+  }
+  /** Check email generation status */
+  async getGenerationStatus(conversationId) {
+    return this.client.get(
+      `/projects/emails/${conversationId}/status`
+    );
+  }
+  /**
+   * Generate an email and wait for completion.
+   * Polls getGenerationStatus until status is 'completed' or 'failed'.
+   */
+  async generateAndWait(params, options) {
+    const startResult = await this.generate(params);
+    if (startResult.error) {
+      return { data: null, error: startResult.error };
+    }
+    const conversationId = startResult.data.conversationId;
+    return poll(
+      () => this.getGenerationStatus(conversationId),
+      (status) => status.status === "completed" || status.status === "failed",
+      options
+    );
+  }
+  /** Send a test email from a completed conversation */
+  async sendTest(params) {
+    return this.client.post(
+      "/emails/test/send",
+      params
+    );
+  }
+};
+
+// src/resources/validation.ts
+var Validation = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async all(params) {
+    return this.client.post(
+      "/emails/validate/all",
+      params
+    );
+  }
+  async compatibility(params) {
+    return this.client.post(
+      "/emails/validate/compatibility",
+      params
+    );
+  }
+  async links(params) {
+    return this.client.post(
+      "/emails/validate/links",
+      params
+    );
+  }
+  async spelling(params) {
+    return this.client.post(
+      "/emails/validate/spelling",
+      params
+    );
+  }
+  async deliverability(params) {
+    return this.client.post(
+      "/emails/validate/deliverability",
+      params
+    );
+  }
+};
+
+// src/resources/previews.ts
+var Previews = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params) {
+    return this.client.post(
+      "/emails/previews",
+      params
+    );
+  }
+  async get(previewId) {
+    return this.client.get(`/emails/previews/${previewId}`);
+  }
+  async getStatus(previewId) {
+    return this.client.get(
+      `/emails/previews/${previewId}/status`
+    );
+  }
+  async getDevice(previewId, deviceKey) {
+    return this.client.get(
+      `/emails/previews/${previewId}/devices/${deviceKey}`
+    );
+  }
+  async getSupportedDevices() {
+    return this.client.get(
+      "/emails/devices/supported"
+    );
+  }
+  /**
+   * Create a preview and wait for completion.
+   * Polls getStatus until status is 'COMPLETED', 'PARTIAL_SUCCESS', or 'FAILED'.
+   */
+  async createAndWait(params, options) {
+    const startResult = await this.create(params);
+    if (startResult.error) {
+      return { data: null, error: startResult.error };
+    }
+    const previewId = startResult.data.previewId;
+    return poll(
+      () => this.get(previewId),
+      (preview) => preview.status === "COMPLETED" || preview.status === "PARTIAL_SUCCESS" || preview.status === "FAILED",
+      options
+    );
+  }
+};
+
+// src/resources/export.ts
+var Export = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getFormats() {
+    return this.client.get("/export/formats");
+  }
+  async getStatus(conversationId) {
+    return this.client.get(
+      `/export/status/${conversationId}`
+    );
+  }
+  async html(conversationId) {
+    return this.client.get(`/export/html/${conversationId}`);
+  }
+  async mjml(conversationId) {
+    return this.client.get(`/export/mjml/${conversationId}`);
+  }
+  async pdf(conversationId) {
+    return this.client.get(`/export/pdf/${conversationId}`);
+  }
+  async klaviyo(conversationId, klaviyoType) {
+    return this.client.get(
+      `/export/klaviyo/${conversationId}`,
+      { klaviyoType }
+    );
+  }
+  async mailchimp(conversationId) {
+    return this.client.get(`/export/mailchimp/${conversationId}`);
+  }
+  async hubspot(params) {
+    return this.client.post(
+      "/export/hubspot",
+      params
+    );
+  }
+};
+
+// src/resources/domains.ts
+var Domains = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.get("/domains");
+  }
+  async create(params) {
+    return this.client.post("/domains", params);
+  }
+  async get(domain) {
+    return this.client.get(`/domains/${domain}`);
+  }
+  async verify(domain) {
+    return this.client.post(`/domains/${domain}/verify`);
+  }
+  async update(domain, params) {
+    return this.client.patch(`/domains/${domain}`, params);
+  }
+  async remove(domain) {
+    return this.client.delete(`/domains/${domain}`);
+  }
+  async checkAvailability(prefix) {
+    return this.client.get(`/domains/managed/check/${prefix}`);
+  }
+  async listManaged() {
+    return this.client.get("/domains/managed");
+  }
+  async createManaged(params) {
+    return this.client.post("/domains/managed", params);
+  }
+  async removeManaged(domain) {
+    return this.client.delete(`/domains/managed/${domain}`);
+  }
+};
+
+// src/resources/webhooks.ts
+var Webhooks = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.get("/webhooks");
+  }
+  async create(params) {
+    return this.client.post("/webhooks", params);
+  }
+  async get(webhookId) {
+    return this.client.get(`/webhooks/${webhookId}`);
+  }
+  async update(webhookId, params) {
+    return this.client.patch(
+      `/webhooks/${webhookId}`,
+      params
+    );
+  }
+  async remove(webhookId) {
+    return this.client.delete(`/webhooks/${webhookId}`);
+  }
+  async test(webhookId) {
+    return this.client.post(`/webhooks/${webhookId}/test`);
+  }
+  async getDeliveries(webhookId, limit) {
+    return this.client.get(
+      `/webhooks/${webhookId}/deliveries`,
+      { limit }
+    );
+  }
+  async getEvents() {
+    return this.client.get("/webhooks/events");
+  }
+  async getStats() {
+    return this.client.get("/webhooks/stats");
+  }
+};
+
+// src/resources/knowledge-base.ts
+var KnowledgeBase = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(projectId) {
+    return this.client.get(
+      `/projects/${projectId}/knowledge-base`
+    );
+  }
+  async add(projectId, params) {
+    return this.client.post(
+      `/projects/${projectId}/knowledge-base`,
+      params
+    );
+  }
+  async update(projectId, entryId, params) {
+    return this.client.put(
+      `/projects/${projectId}/knowledge-base/${entryId}`,
+      params
+    );
+  }
+  async remove(projectId, entryId) {
+    return this.client.delete(
+      `/projects/${projectId}/knowledge-base/${entryId}`
+    );
+  }
+};
+
+// src/resources/images.ts
+var Images = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async add(projectId, params) {
+    return this.client.post(
+      `/projects/${projectId}/images`,
+      params
+    );
+  }
+  async update(projectId, params) {
+    return this.client.put(
+      `/projects/${projectId}/images`,
+      params
+    );
+  }
+  async remove(projectId, imageUrl) {
+    return this.client.delete(
+      `/projects/${projectId}/images`,
+      { imageUrl }
+    );
+  }
+  async updateLogos(projectId, params) {
+    return this.client.put(
+      `/projects/${projectId}/logos`,
+      params
+    );
+  }
+};
+
+// src/migma.ts
+var Migma = class {
+  client;
+  contacts;
+  tags;
+  segments;
+  topics;
+  sending;
+  projects;
+  emails;
+  validation;
+  previews;
+  export;
+  domains;
+  webhooks;
+  knowledgeBase;
+  images;
+  constructor(apiKey, config) {
+    if (!apiKey) {
+      throw new Error(
+        'Missing API key. Pass it to the constructor: `new Migma("your-api-key")`'
+      );
+    }
+    this.client = new MigmaClient(apiKey, {
+      baseUrl: config?.baseUrl ?? "https://api.migma.ai/api/v1",
+      timeout: config?.timeout ?? 3e4,
+      maxRetries: config?.maxRetries ?? 2,
+      retryDelay: config?.retryDelay ?? 1e3
+    });
+    this.contacts = new Contacts(this.client);
+    this.tags = new Tags(this.client);
+    this.segments = new Segments(this.client);
+    this.topics = new Topics(this.client);
+    this.sending = new Sending(this.client);
+    this.projects = new Projects(this.client);
+    this.emails = new Emails(this.client);
+    this.validation = new Validation(this.client);
+    this.previews = new Previews(this.client);
+    this.export = new Export(this.client);
+    this.domains = new Domains(this.client);
+    this.webhooks = new Webhooks(this.client);
+    this.knowledgeBase = new KnowledgeBase(this.client);
+    this.images = new Images(this.client);
+  }
+};
+
+exports.Migma = Migma;
+exports.MigmaClient = MigmaClient;
+exports.MigmaError = MigmaError;
+exports.MigmaErrorCode = MigmaErrorCode;
+exports.poll = poll;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map