@semboja/connect 0.1.0

package/dist/index.js

@@ -0,0 +1,635 @@
+"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, {
+  AuthenticationError: () => AuthenticationError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  RateLimitError: () => RateLimitError,
+  SembojaClient: () => SembojaClient,
+  SembojaError: () => SembojaError,
+  ServerError: () => ServerError,
+  ValidationError: () => ValidationError,
+  parseWebhookPayload: () => parseWebhookPayload,
+  verifyWebhookSignature: () => verifyWebhookSignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SembojaError = class _SembojaError extends Error {
+  /** Error code from the API */
+  code;
+  /** HTTP status code */
+  statusCode;
+  /** Request ID for debugging */
+  requestId;
+  constructor(message, code, statusCode, requestId) {
+    super(message);
+    this.name = "SembojaError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    Object.setPrototypeOf(this, _SembojaError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends SembojaError {
+  constructor(message, requestId) {
+    super(message, "INVALID_API_KEY", 401, requestId);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends SembojaError {
+  /** When the rate limit resets (Unix timestamp) */
+  resetAt;
+  constructor(message, requestId, resetAt) {
+    super(message, "RATE_LIMITED", 429, requestId);
+    this.name = "RateLimitError";
+    this.resetAt = resetAt;
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends SembojaError {
+  constructor(message, requestId) {
+    super(message, "VALIDATION_ERROR", 400, requestId);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends SembojaError {
+  constructor(message, code, requestId) {
+    super(message, code, 404, requestId);
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var ServerError = class _ServerError extends SembojaError {
+  constructor(message, requestId) {
+    super(message, "INTERNAL_ERROR", 500, requestId);
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends SembojaError {
+  constructor(message) {
+    super(message, "NETWORK_ERROR", 0);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+
+// src/lib/http.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getBackoffDelay(attempt, baseDelay = 1e3) {
+  return Math.min(baseDelay * Math.pow(2, attempt), 3e4);
+}
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  retries;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout;
+    this.retries = options.retries;
+  }
+  /**
+   * Make an HTTP request with retry logic
+   */
+  async request(options) {
+    const url = `${this.baseUrl}${options.path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey,
+      ...options.headers
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          method: options.method,
+          headers,
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const data = await response.json();
+        if (!response.ok) {
+          throw this.parseError(response.status, data);
+        }
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof SembojaError) {
+          if (error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
+            throw error;
+          }
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new NetworkError(`Request timeout after ${this.timeout}ms`);
+        }
+        if (attempt < this.retries) {
+          const delay = getBackoffDelay(attempt);
+          await sleep(delay);
+          continue;
+        }
+      }
+    }
+    if (lastError instanceof SembojaError) {
+      throw lastError;
+    }
+    throw new NetworkError(lastError?.message || "Request failed");
+  }
+  /**
+   * Parse error response into appropriate error class
+   */
+  parseError(statusCode, data) {
+    const message = data.error?.message || "Unknown error";
+    const code = data.error?.code || "UNKNOWN_ERROR";
+    const requestId = data.meta?.request_id;
+    switch (statusCode) {
+      case 401:
+        return new AuthenticationError(message, requestId);
+      case 429:
+        return new RateLimitError(message, requestId);
+      case 400:
+        return new ValidationError(message, requestId);
+      case 404:
+        return new NotFoundError(message, code, requestId);
+      case 500:
+      case 502:
+      case 503:
+        return new ServerError(message, requestId);
+      default:
+        return new SembojaError(message, code, statusCode, requestId);
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(path) {
+    return this.request({ method: "GET", path });
+  }
+  /**
+   * POST request
+   */
+  async post(path, body) {
+    return this.request({ method: "POST", path, body });
+  }
+};
+
+// src/resources/messages.ts
+var Messages = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Send a text message
+   * 
+   * @param options - Text message options
+   * @returns Message response with message ID
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.messages.sendText({
+   *   phoneNumberId: '123456789',
+   *   to: '+6281234567890',
+   *   text: 'Hello, World!',
+   *   previewUrl: true,
+   * });
+   * console.log('Message ID:', result.data.messages[0].id);
+   * ```
+   */
+  async sendText(options) {
+    return this.http.post("/api/v1/messages/text", {
+      phone_number_id: options.phoneNumberId,
+      to: options.to,
+      text: options.text,
+      preview_url: options.previewUrl,
+      reply_to: options.replyTo
+    });
+  }
+  /**
+   * Send a template message
+   * 
+   * @param options - Template message options
+   * @returns Message response with message ID
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.messages.sendTemplate({
+   *   phoneNumberId: '123456789',
+   *   to: '+6281234567890',
+   *   template: {
+   *     name: 'hello_world',
+   *     language: { code: 'en' },
+   *   },
+   * });
+   * ```
+   */
+  async sendTemplate(options) {
+    return this.http.post("/api/v1/messages/template", {
+      phone_number_id: options.phoneNumberId,
+      to: options.to,
+      template: options.template
+    });
+  }
+  /**
+   * Send an image message
+   * 
+   * @param options - Image message options
+   * @returns Message response with message ID
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.messages.sendImage({
+   *   phoneNumberId: '123456789',
+   *   to: '+6281234567890',
+   *   image: {
+   *     link: 'https://example.com/image.jpg',
+   *     caption: 'Check this out!',
+   *   },
+   * });
+   * ```
+   */
+  async sendImage(options) {
+    return this.http.post("/api/v1/messages", {
+      phone_number_id: options.phoneNumberId,
+      to: options.to,
+      type: "image",
+      image: options.image,
+      context: options.replyTo ? { message_id: options.replyTo } : void 0
+    });
+  }
+  /**
+   * Send a video message
+   * 
+   * @param options - Video message options
+   * @returns Message response with message ID
+   */
+  async sendVideo(options) {
+    return this.http.post("/api/v1/messages", {
+      phone_number_id: options.phoneNumberId,
+      to: options.to,
+      type: "video",
+      video: options.video,
+      context: options.replyTo ? { message_id: options.replyTo } : void 0
+    });
+  }
+  /**
+   * Send an audio message
+   * 
+   * @param options - Audio message options
+   * @returns Message response with message ID
+   */
+  async sendAudio(options) {
+    return this.http.post("/api/v1/messages", {
+      phone_number_id: options.phoneNumberId,
+      to: options.to,
+      type: "audio",
+      audio: options.audio,
+      context: options.replyTo ? { message_id: options.replyTo } : void 0
+    });
+  }
+  /**
+   * Send a document message
+   * 
+   * @param options - Document message options
+   * @returns Message response with message ID
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.messages.sendDocument({
+   *   phoneNumberId: '123456789',
+   *   to: '+6281234567890',
+   *   document: {
+   *     link: 'https://example.com/invoice.pdf',
+   *     filename: 'invoice.pdf',
+   *     caption: 'Your invoice',
+   *   },
+   * });
+   * ```
+   */
+  async sendDocument(options) {
+    return this.http.post("/api/v1/messages", {
+      phone_number_id: options.phoneNumberId,
+      to: options.to,
+      type: "document",
+      document: options.document,
+      context: options.replyTo ? { message_id: options.replyTo } : void 0
+    });
+  }
+  /**
+   * Send a reaction to a message
+   * 
+   * @param options - Reaction options
+   * @returns Message response
+   * 
+   * @example
+   * ```typescript
+   * // Add reaction
+   * await client.messages.sendReaction({
+   *   phoneNumberId: '123456789',
+   *   to: '+6281234567890',
+   *   reaction: {
+   *     messageId: 'wamid.xxx',
+   *     emoji: '👍',
+   *   },
+   * });
+   * 
+   * // Remove reaction
+   * await client.messages.sendReaction({
+   *   phoneNumberId: '123456789',
+   *   to: '+6281234567890',
+   *   reaction: {
+   *     messageId: 'wamid.xxx',
+   *     emoji: '',
+   *   },
+   * });
+   * ```
+   */
+  async sendReaction(options) {
+    return this.http.post("/api/v1/messages", {
+      phone_number_id: options.phoneNumberId,
+      to: options.to,
+      type: "reaction",
+      reaction: {
+        message_id: options.reaction.messageId,
+        emoji: options.reaction.emoji
+      }
+    });
+  }
+  /**
+   * Send an interactive message (buttons, lists, etc.)
+   * 
+   * @param options - Interactive message options
+   * @returns Message response with message ID
+   * 
+   * @example
+   * ```typescript
+   * // Button message
+   * await client.messages.sendInteractive({
+   *   phoneNumberId: '123456789',
+   *   to: '+6281234567890',
+   *   interactive: {
+   *     type: 'button',
+   *     body: { text: 'Choose an option:' },
+   *     action: {
+   *       buttons: [
+   *         { type: 'reply', reply: { id: 'yes', title: 'Yes' } },
+   *         { type: 'reply', reply: { id: 'no', title: 'No' } },
+   *       ],
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  async sendInteractive(options) {
+    return this.http.post("/api/v1/messages", {
+      phone_number_id: options.phoneNumberId,
+      to: options.to,
+      type: "interactive",
+      interactive: options.interactive,
+      context: options.replyTo ? { message_id: options.replyTo } : void 0
+    });
+  }
+};
+
+// src/resources/templates.ts
+var Templates = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all message templates
+   * 
+   * @param options - Optional filters
+   * @returns List of templates
+   * 
+   * @example
+   * ```typescript
+   * const templates = await client.templates.list();
+   * console.log('Templates:', templates.data);
+   * 
+   * // Filter by status
+   * const approved = await client.templates.list({ status: 'APPROVED' });
+   * ```
+   */
+  async list(options) {
+    let path = "/api/v1/templates";
+    if (options?.status) {
+      path += `?status=${encodeURIComponent(options.status)}`;
+    }
+    return this.http.get(path);
+  }
+};
+
+// src/resources/phone-numbers.ts
+var PhoneNumbers = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all phone numbers configured for your account
+   * 
+   * @returns List of phone numbers
+   * 
+   * @example
+   * ```typescript
+   * const phoneNumbers = await client.phoneNumbers.list();
+   * for (const phone of phoneNumbers.data) {
+   *   console.log(`${phone.verified_name}: ${phone.display_phone_number}`);
+   * }
+   * ```
+   */
+  async list() {
+    return this.http.get("/api/v1/phone-numbers");
+  }
+};
+
+// src/resources/usage.ts
+var Usage = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get current usage statistics for the billing period
+   * 
+   * @returns Usage statistics
+   * 
+   * @example
+   * ```typescript
+   * const usage = await client.usage.get();
+   * console.log(`Period: ${usage.data.period.start} - ${usage.data.period.end}`);
+   * console.log(`Messages sent: ${usage.data.messages.sent}`);
+   * console.log(`Messages received: ${usage.data.messages.received}`);
+   * console.log(`API calls: ${usage.data.api_calls}`);
+   * ```
+   */
+  async get() {
+    return this.http.get("/api/v1/usage");
+  }
+};
+
+// src/resources/test.ts
+var Test = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Trigger a test webhook to simulate an incoming message
+   * 
+   * **Note:** This only works with test API keys (sk_test_*)
+   * 
+   * @param options - Webhook trigger options
+   * @returns Success response
+   * 
+   * @example
+   * ```typescript
+   * await client.test.triggerWebhook({
+   *   phoneNumberId: '123456789',
+   *   type: 'text',
+   *   from: '+6281234567890',
+   *   text: 'Hello, this is a test incoming message!',
+   * });
+   * ```
+   */
+  async triggerWebhook(options) {
+    return this.http.post("/api/v1/test/webhooks/trigger", {
+      phone_number_id: options.phoneNumberId,
+      type: options.type || "text",
+      from: options.from,
+      text: options.text
+    });
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://connect.semboja.tech";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRIES = 3;
+var SembojaClient = class {
+  /** Messages API */
+  messages;
+  /** Templates API */
+  templates;
+  /** Phone Numbers API */
+  phoneNumbers;
+  /** Usage API */
+  usage;
+  /** Test API (only works with sk_test_* keys) */
+  test;
+  /** Whether the client is in test mode */
+  isTestMode;
+  http;
+  /**
+   * Create a new Semboja client
+   * 
+   * @param optionsOrApiKey - API key string or client options object
+   * 
+   * @example
+   * ```typescript
+   * // Using API key directly
+   * const client = new SembojaClient('sk_live_xxx');
+   * 
+   * // Using options object
+   * const client = new SembojaClient({
+   *   apiKey: 'sk_live_xxx',
+   *   timeout: 60000,
+   *   retries: 5,
+   * });
+   * ```
+   */
+  constructor(optionsOrApiKey) {
+    const options = typeof optionsOrApiKey === "string" ? { apiKey: optionsOrApiKey } : optionsOrApiKey;
+    if (!options.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!options.apiKey.startsWith("sk_live_") && !options.apiKey.startsWith("sk_test_")) {
+      throw new Error("Invalid API key format. Must start with sk_live_ or sk_test_");
+    }
+    this.isTestMode = options.apiKey.startsWith("sk_test_");
+    this.http = new HttpClient({
+      baseUrl: options.baseUrl || DEFAULT_BASE_URL,
+      apiKey: options.apiKey,
+      timeout: options.timeout || DEFAULT_TIMEOUT,
+      retries: options.retries ?? DEFAULT_RETRIES
+    });
+    this.messages = new Messages(this.http);
+    this.templates = new Templates(this.http);
+    this.phoneNumbers = new PhoneNumbers(this.http);
+    this.usage = new Usage(this.http);
+    this.test = new Test(this.http);
+  }
+};
+
+// src/webhooks/verify.ts
+var import_crypto = require("crypto");
+function verifyWebhookSignature(options) {
+  const { payload, signature, timestamp, secret } = options;
+  if (!payload || !signature || !timestamp || !secret) {
+    return false;
+  }
+  const timestampNum = parseInt(timestamp, 10);
+  const now = Math.floor(Date.now() / 1e3);
+  const tolerance = 5 * 60;
+  if (isNaN(timestampNum) || Math.abs(now - timestampNum) > tolerance) {
+    return false;
+  }
+  const payloadString = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const signatureData = timestamp + payloadString;
+  const expectedSignature = "sha256=" + (0, import_crypto.createHmac)("sha256", secret).update(signatureData).digest("hex");
+  try {
+    const sigBuffer = Buffer.from(signature);
+    const expectedBuffer = Buffer.from(expectedSignature);
+    if (sigBuffer.length !== expectedBuffer.length) {
+      return false;
+    }
+    return (0, import_crypto.timingSafeEqual)(sigBuffer, expectedBuffer);
+  } catch {
+    return false;
+  }
+}
+function parseWebhookPayload(payload) {
+  if (typeof payload === "string") {
+    return JSON.parse(payload);
+  }
+  return payload;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  NetworkError,
+  NotFoundError,
+  RateLimitError,
+  SembojaClient,
+  SembojaError,
+  ServerError,
+  ValidationError,
+  parseWebhookPayload,
+  verifyWebhookSignature
+});
+//# sourceMappingURL=index.js.map