@dora-cell/sdk 1.0.0 → 1.0.2

package/README.md

@@ -8,9 +8,10 @@ VoIP calling SDK for Dora Cell - Make calls from any JavaScript application with
 ✅ **TypeScript support** - Full type definitions included  
 ✅ **WebRTC-based** - High-quality voice calls using JsSIP  
 ✅ **Event-driven API** - Listen to call state changes  
-✅ **Multiple Auth Modes** - Support for API Token and Direct Extension login  
-✅ **Auto-extension selection** - Automatically selects first available extension  
-✅ **React bindings** - Optional React hooks for easy integration
+✅ **API Token Auth** - Securely authenticate with Public & Secret keys  
+✅ **Dynamic Extensions** - Fetch and switch between DID numbers  
+✅ **Wallet Integration** - Check credit balance directly from the SDK  
+✅ **React bindings** - Premium UI components and hooks included
 
 ## Installation
 
@@ -48,14 +49,14 @@ const sdk = new DoraCell({
 
 #### Option B: API Token Authentication (Production)
 
-Securely fetch credentials from your backend.
+Best for production apps. The SDK will verify keys and fetch SIP credentials automatically.
 
 ```javascript
 const sdk = new DoraCell({
   auth: {
     type: "api-token",
-    apiToken: "your-api-token-here",
-    // apiBaseUrl: "https://api.yourdomain.com", // Optional override
+    publicKey: "pk_live_...",
+    secretKey: "sk_live_...",
   },
 });
 ```
@@ -112,17 +113,20 @@ try {
 #### `new DoraCell(config)`
 
 - `config.auth` (Required)
-  - `type: 'extension' | 'api-token'`
-  - `extension: string` (for extension type)
-  - `apiToken: string` (for api-token type)
+  - `type: 'api-token' | 'extension' | 'direct'`
+  - `publicKey/secretKey` (for api-token)
+  - `extension` (for extension type)
+- `config.environment?: 'dev' | 'staging' | 'production'` - Shortcut for API URLs (default: 'production')
+- `config.autoSelectExtension?: boolean` - Register first available DID (default: true)
 - `config.debug?: boolean` - Enable JsSIP debug logs (default: false)
 
 #### Methods
 
-- `initialize(): Promise<void>` - Connect to the SIP server and register the extension.
-- `call(number, options?): Promise<Call>` - Initiate an outbound call.
-  - `options.extension`: Specify a specific extension to call from.
-  - `options.mediaConstraints`: Custom WebRTC media constraints.
+- `initialize(): Promise<void>` - Authenticate and register with the SIP server.
+- `call(number, extension?): Promise<Call>` - Initiate an outbound call.
+- `getWallet(): Promise<{ balance: number, currency: string }>` - Get current credit balance.
+- `fetchExtensions(): Promise<Extension[]>` - Fetch available DID numbers/extensions.
+- `setExtension(ext): Promise<void>` - Switch active extension and re-register SIP.
 - `answerCall(): void` - Answer a pending incoming call.
 - `hangup(): void` - End the current active call.
 - `on(event, handler): void` - Listen for events (see below).
@@ -145,7 +149,7 @@ Returned by `call()` and emitted in events.
 
 | Event               | Description                    | Data                               |
 | ------------------- | ------------------------------ | ---------------------------------- |
-| `connection:status` | SIP registration status change | `{ status: string, error?: string }` |
+| `connection:status` | SIP registration status change | `{ status: string, extension?: string, error?: string }` |
 | `call:incoming`     | New incoming call detected     | `Call` object                      |
 | `call:outgoing`     | New outbound call started      | `Call` object                      |
 | `call:ringing`      | Remote party is ringing        | `Call` object                      |

package/dist/index.d.mts

@@ -5,8 +5,8 @@ import EventEmitter from 'eventemitter3';
  */
 interface ApiTokenAuth {
     type: 'api-token';
-    apiToken: string;
-    apiBaseUrl?: string;
+    publicKey: string;
+    secretKey: string;
 }
 interface DirectCredentialsAuth {
     type: 'direct';
@@ -21,8 +21,11 @@ interface ExtensionAuth {
     sipDomain?: string;
 }
 type AuthConfig = ApiTokenAuth | DirectCredentialsAuth | ExtensionAuth;
+type DoraCellEnv = 'dev' | 'staging' | 'production' | 'local';
 interface DoraCellConfig {
     auth: AuthConfig;
+    apiBaseUrl?: string;
+    environment?: DoraCellEnv;
     sipServer?: string;
     turnServers?: RTCIceServer[];
     debug?: boolean;
@@ -106,6 +109,8 @@ declare class DoraCell {
     private credentials;
     private ua;
     private callManager;
+    private apiClient;
+    private apiBaseUrl;
     private connectionStatus;
     private retryCount;
     private maxRetries;
@@ -134,14 +139,29 @@ declare class DoraCell {
      * Get current call
      */
     getCurrentCall(): Call | null;
+    /**
+     * Get user's wallet/credit balance
+     */
+    getWallet(): Promise<{
+        balance: number;
+        currency: string;
+    }>;
     /**
      * Get connection status
      */
     getStatus(): ConnectionStatus;
     /**
-     * Get available extensions
+     * Fetch available extensions (DID numbers) from the API
+     */
+    fetchExtensions(): Promise<any[]>;
+    /**
+     * Get available extensions (DID numbers)
+     */
+    getExtensions(): any[];
+    /**
+     * Update active extension and re-initialize SIP connection
      */
-    getExtensions(): string[];
+    setExtension(extension: string): Promise<void>;
     /**
      * Event listener management
      */
@@ -157,6 +177,7 @@ declare class DoraCell {
     private getDefaultTurnServers;
     private getDisplayName;
     private generateInstanceId;
+    private resolveApiBaseUrl;
 }
 
 /**
@@ -215,4 +236,4 @@ declare function extractNumberFromSipUri(sipUri: string): string;
  */
 declare function isValidPhoneNumber(phone: string, minLength?: number): boolean;
 
-export { type ApiTokenAuth, type AuthConfig, AuthenticationError, type Call, type CallDirection, CallError, type CallOptions, CallSession, type CallStatus, ConnectionError, type ConnectionState, type ConnectionStatus, type DirectCredentialsAuth, DoraCell, type DoraCellConfig, DoraCellError, type DoraCellEvent, type DoraCellEventMap, type Extension, type SipCredentials, DoraCell as default, extractNumberFromSipUri, formatPhoneToSIP, isValidPhoneNumber, normalizePhoneNumber };
+export { type ApiTokenAuth, type AuthConfig, AuthenticationError, type Call, type CallDirection, CallError, type CallOptions, CallSession, type CallStatus, ConnectionError, type ConnectionState, type ConnectionStatus, type DirectCredentialsAuth, DoraCell, type DoraCellConfig, DoraCellError, type DoraCellEvent, type DoraCellEventMap, type Extension, type ExtensionAuth, type SipCredentials, DoraCell as default, extractNumberFromSipUri, formatPhoneToSIP, isValidPhoneNumber, normalizePhoneNumber };

package/dist/index.d.ts

@@ -5,8 +5,8 @@ import EventEmitter from 'eventemitter3';
  */
 interface ApiTokenAuth {
     type: 'api-token';
-    apiToken: string;
-    apiBaseUrl?: string;
+    publicKey: string;
+    secretKey: string;
 }
 interface DirectCredentialsAuth {
     type: 'direct';
@@ -21,8 +21,11 @@ interface ExtensionAuth {
     sipDomain?: string;
 }
 type AuthConfig = ApiTokenAuth | DirectCredentialsAuth | ExtensionAuth;
+type DoraCellEnv = 'dev' | 'staging' | 'production' | 'local';
 interface DoraCellConfig {
     auth: AuthConfig;
+    apiBaseUrl?: string;
+    environment?: DoraCellEnv;
     sipServer?: string;
     turnServers?: RTCIceServer[];
     debug?: boolean;
@@ -106,6 +109,8 @@ declare class DoraCell {
     private credentials;
     private ua;
     private callManager;
+    private apiClient;
+    private apiBaseUrl;
     private connectionStatus;
     private retryCount;
     private maxRetries;
@@ -134,14 +139,29 @@ declare class DoraCell {
      * Get current call
      */
     getCurrentCall(): Call | null;
+    /**
+     * Get user's wallet/credit balance
+     */
+    getWallet(): Promise<{
+        balance: number;
+        currency: string;
+    }>;
     /**
      * Get connection status
      */
     getStatus(): ConnectionStatus;
     /**
-     * Get available extensions
+     * Fetch available extensions (DID numbers) from the API
+     */
+    fetchExtensions(): Promise<any[]>;
+    /**
+     * Get available extensions (DID numbers)
+     */
+    getExtensions(): any[];
+    /**
+     * Update active extension and re-initialize SIP connection
      */
-    getExtensions(): string[];
+    setExtension(extension: string): Promise<void>;
     /**
      * Event listener management
      */
@@ -157,6 +177,7 @@ declare class DoraCell {
     private getDefaultTurnServers;
     private getDisplayName;
     private generateInstanceId;
+    private resolveApiBaseUrl;
 }
 
 /**
@@ -215,4 +236,4 @@ declare function extractNumberFromSipUri(sipUri: string): string;
  */
 declare function isValidPhoneNumber(phone: string, minLength?: number): boolean;
 
-export { type ApiTokenAuth, type AuthConfig, AuthenticationError, type Call, type CallDirection, CallError, type CallOptions, CallSession, type CallStatus, ConnectionError, type ConnectionState, type ConnectionStatus, type DirectCredentialsAuth, DoraCell, type DoraCellConfig, DoraCellError, type DoraCellEvent, type DoraCellEventMap, type Extension, type SipCredentials, DoraCell as default, extractNumberFromSipUri, formatPhoneToSIP, isValidPhoneNumber, normalizePhoneNumber };
+export { type ApiTokenAuth, type AuthConfig, AuthenticationError, type Call, type CallDirection, CallError, type CallOptions, CallSession, type CallStatus, ConnectionError, type ConnectionState, type ConnectionStatus, type DirectCredentialsAuth, DoraCell, type DoraCellConfig, DoraCellError, type DoraCellEvent, type DoraCellEventMap, type Extension, type ExtensionAuth, type SipCredentials, DoraCell as default, extractNumberFromSipUri, formatPhoneToSIP, isValidPhoneNumber, normalizePhoneNumber };

package/dist/index.js

@@ -23003,43 +23003,41 @@ var ConnectionError = class extends DoraCellError {
 
 // src/core/AuthProvider.ts
 var ApiTokenAuthProvider = class {
-  constructor(apiToken, apiBaseUrl) {
+  constructor(publicKey, secretKey) {
     this.credentials = null;
-    this.apiToken = apiToken;
-    let defaultBaseUrl = "";
-    if (typeof process !== "undefined" && process.env) {
-      defaultBaseUrl = process.env.NEXT_PUBLIC_BASE_API_URL || "";
-    }
-    this.apiBaseUrl = apiBaseUrl || defaultBaseUrl;
+    this.sessionToken = null;
+    this.publicKey = publicKey;
+    this.secretKey = secretKey;
   }
-  async authenticate(config) {
+  async authenticate(config, apiBaseUrl) {
     if (config.type !== "api-token") {
       throw new AuthenticationError("Invalid auth config type for ApiTokenAuthProvider");
     }
+    const baseUrl = apiBaseUrl?.replace(/\/$/, "") || "https://api.cell.usedora.com/api";
     try {
-      const response = await fetch(`${this.apiBaseUrl}/api/sip-credentials`, {
-        method: "GET",
+      console.log("SDK: Verifying keys at:", `${baseUrl}/sdk/v1/auth/session`);
+      const authResponse = await fetch(`${baseUrl}/sdk/v1/auth/session`, {
+        method: "POST",
         headers: {
-          "Authorization": `Bearer ${this.apiToken}`,
           "Content-Type": "application/json",
           "Accept": "application/json"
         },
-        credentials: "include"
+        body: JSON.stringify({
+          secret_key: this.secretKey
+        })
       });
-      if (!response.ok) {
-        if (response.status === 401 || response.status === 403) {
-          throw new AuthenticationError(
-            "Invalid API token or insufficient permissions",
-            { status: response.status }
-          );
-        }
+      if (!authResponse.ok) {
         throw new AuthenticationError(
-          `Failed to fetch SIP credentials: ${response.status}`,
-          { status: response.status }
+          `Key verification failed: ${authResponse.status}`,
+          { status: authResponse.status }
         );
       }
-      const data = await response.json();
-      this.credentials = this.parseCredentials(data);
+      const authData = await authResponse.json();
+      this.sessionToken = authData.session_token || authData.token || authData.data?.session_token;
+      if (!this.sessionToken) {
+        throw new AuthenticationError("No session token returned after key verification");
+      }
+      this.credentials = this.parseCredentials(authData);
       return this.credentials;
     } catch (error) {
       if (error instanceof AuthenticationError) {
@@ -23051,28 +23049,38 @@ var ApiTokenAuthProvider = class {
       );
     }
   }
-  async refreshCredentials() {
-    return this.authenticate({ type: "api-token", apiToken: this.apiToken });
+  async refreshCredentials(apiBaseUrl) {
+    return this.authenticate({
+      type: "api-token",
+      publicKey: this.publicKey,
+      secretKey: this.secretKey
+    }, apiBaseUrl);
   }
   isAuthenticated() {
-    return this.credentials !== null;
+    return this.credentials !== null && this.sessionToken !== null;
+  }
+  getSessionToken() {
+    return this.sessionToken;
   }
   parseCredentials(data) {
-    const wsUrl = data.ws_url || data.wsUrl;
-    const sipUri = data.sip_uri || data.sipUri;
-    const password = data.password;
-    const sipDomain = data.sip_domain || data.sipDomain;
-    const extensions = data.extensions;
+    const DEFAULT_WSS_URL = "wss://cell.usedora.com:8089/ws";
+    const DEFAULT_SIP_IP = "64.227.10.164";
+    const DEFAULT_PASSWORD = "1234";
+    const wsUrl = data.ws_url || data.wsUrl || DEFAULT_WSS_URL;
+    const sipDomain = data.sip_domain || data.sipDomain || DEFAULT_SIP_IP;
+    const password = data.password || DEFAULT_PASSWORD;
+    const extensions = data.extensions || [];
     const expiresIn = data.expires_in || data.expiresIn;
-    if (!wsUrl || !sipUri) {
-      throw new AuthenticationError(
-        "Invalid credentials response: missing ws_url or sip_uri"
-      );
+    let sipUri = data.sip_uri || data.sipUri;
+    if (!sipUri && extensions.length > 0) {
+      const ext = extensions[0].extension;
+      sipUri = `sip:${ext}@${sipDomain}`;
+      console.log(`SDK: Constructed SIP URI from extension: ${sipUri}`);
     }
     return {
       wsUrl,
-      sipUri,
-      password: password || "",
+      sipUri: sipUri || "",
+      password,
       sipDomain,
       extensions,
       expiresIn
@@ -23080,64 +23088,42 @@ var ApiTokenAuthProvider = class {
   }
 };
 var DirectCredentialsAuthProvider = class {
-  constructor() {
-    this.credentials = null;
+  constructor(sipUri, password, wsUrl) {
+    this.credentials = { sipUri, password, wsUrl, extensions: [] };
   }
-  async authenticate(config) {
-    if (config.type !== "direct") {
-      throw new AuthenticationError("Invalid auth config type for DirectCredentialsAuthProvider");
-    }
-    this.credentials = {
-      wsUrl: config.wsUrl,
-      sipUri: config.sipUri,
-      password: config.password
-    };
+  async authenticate() {
     return this.credentials;
   }
   isAuthenticated() {
-    return this.credentials !== null;
+    return true;
   }
 };
-var DEFAULT_WSS_URL = "wss://cell.usedora.com:8089/ws";
-var DEFAULT_SIP_IP = "64.227.10.164";
-var DEFAULT_PASSWORD = "1234";
 var ExtensionAuthProvider = class {
-  constructor() {
-    this.credentials = null;
-  }
-  async authenticate(config) {
-    if (config.type !== "extension") {
-      throw new AuthenticationError("Invalid auth config type for ExtensionAuthProvider");
-    }
-    const extension = config.extension;
-    const password = config.password || DEFAULT_PASSWORD;
-    const wsUrl = DEFAULT_WSS_URL;
-    const sipDomain = config.sipDomain || DEFAULT_SIP_IP;
-    const sipUri = `sip:${extension}@${sipDomain}`;
+  constructor(extension, password = "1234", sipDomain = "64.227.10.164") {
     this.credentials = {
-      wsUrl,
-      sipUri,
+      sipUri: `sip:${extension}@${sipDomain}`,
       password,
-      sipDomain,
-      extensions: [{ extension, displayName: `Ext ${extension}`, isPrimary: true }]
+      wsUrl: "wss://cell.usedora.com:8089/ws",
+      extensions: [{ extension, isPrimary: true }],
+      sipDomain
     };
+  }
+  async authenticate() {
     return this.credentials;
   }
   isAuthenticated() {
-    return this.credentials !== null;
+    return true;
   }
 };
 function createAuthProvider(config) {
-  switch (config.type) {
-    case "api-token":
-      return new ApiTokenAuthProvider(config.apiToken, config.apiBaseUrl);
-    case "direct":
-      return new DirectCredentialsAuthProvider();
-    case "extension":
-      return new ExtensionAuthProvider();
-    default:
-      throw new AuthenticationError("Unknown authentication type");
+  if (config.type === "api-token") {
+    return new ApiTokenAuthProvider(config.publicKey, config.secretKey);
+  } else if (config.type === "direct") {
+    return new DirectCredentialsAuthProvider(config.sipUri, config.password, config.wsUrl);
+  } else if (config.type === "extension") {
+    return new ExtensionAuthProvider(config.extension, config.password, config.sipDomain);
   }
+  throw new AuthenticationError("Unknown authentication type");
 }
 
 // src/utils/phoneFormatter.ts
@@ -23411,6 +23397,64 @@ var CallManager = class {
   }
 };
 
+// src/core/ApiClient.ts
+var ApiClient = class {
+  constructor(baseUrl) {
+    this.sessionToken = null;
+    this.baseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  }
+  setSessionToken(token) {
+    this.sessionToken = token;
+  }
+  getSessionToken() {
+    return this.sessionToken;
+  }
+  async post(path, data, headers = {}) {
+    return this.request(path, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(data)
+    });
+  }
+  async get(path, headers = {}) {
+    return this.request(path, {
+      method: "GET",
+      headers: {
+        ...headers
+      }
+    });
+  }
+  async request(path, options) {
+    const url = path.startsWith("http") ? path : `${this.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
+    const headers = {
+      ...options.headers
+    };
+    if (this.sessionToken && !headers["Authorization"]) {
+      headers["Authorization"] = `Bearer ${this.sessionToken}`;
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch (e) {
+        errorData = { message: response.statusText };
+      }
+      const error = new Error(errorData.message || `API Request failed: ${response.status}`);
+      error.status = response.status;
+      error.data = errorData;
+      throw error;
+    }
+    return response.json();
+  }
+};
+
 // src/core/DoraCell.ts
 var DoraCell = class {
   constructor(config) {
@@ -23428,6 +23472,8 @@ var DoraCell = class {
     };
     this.events = new eventemitter3_default();
     this.authProvider = createAuthProvider(config.auth);
+    this.apiBaseUrl = this.resolveApiBaseUrl(config);
+    this.apiClient = new ApiClient(this.apiBaseUrl);
     if (this.config.debug) {
       import_jssip.default.debug.enable("JsSIP:*");
     }
@@ -23437,7 +23483,20 @@ var DoraCell = class {
    */
   async initialize() {
     try {
-      this.credentials = await this.authProvider.authenticate(this.config.auth);
+      this.credentials = await this.authProvider.authenticate(
+        this.config.auth,
+        this.apiBaseUrl
+      );
+      if (this.authProvider instanceof ApiTokenAuthProvider) {
+        const token = this.authProvider.getSessionToken();
+        if (token) this.apiClient.setSessionToken(token);
+      }
+      if (this.config.autoSelectExtension && this.credentials?.extensions && this.credentials.extensions.length > 0) {
+        const primary = this.credentials.extensions.find((e) => e.isPrimary) || this.credentials.extensions[0];
+        const domain = this.credentials.sipDomain || "cell.usedora.com";
+        this.credentials.sipUri = `sip:${primary.extension}@${domain}`;
+        console.log(`SDK: Auto-selected extension ${primary.extension}`);
+      }
       await this.initializeUserAgent();
       this.initializeCallManager();
       await this.waitForRegistration();
@@ -23590,6 +23649,35 @@ var DoraCell = class {
   getCurrentCall() {
     return this.callManager?.getCurrentCall() || null;
   }
+  /**
+   * Get user's wallet/credit balance
+   */
+  async getWallet() {
+    const token = this.apiClient.getSessionToken();
+    if (!token) {
+      console.warn("SDK: Cannot fetch wallet, no session token available.");
+      return { balance: 0, currency: "NGN" };
+    }
+    try {
+      console.log("SDK: Fetching wallet balance...");
+      const response = await this.apiClient.get("/wallets");
+      const wallets = Array.isArray(response) ? response : response.data || [];
+      if (wallets.length === 0) {
+        console.log("SDK: No wallets found for user.");
+        return { balance: 0, currency: "NGN" };
+      }
+      const primary = wallets[0];
+      const result = {
+        balance: parseFloat(primary.balance || "0"),
+        currency: primary.currency || "NGN"
+      };
+      console.log("SDK: Wallet balance fetched:", result);
+      return result;
+    } catch (error) {
+      console.error("SDK: Failed to fetch wallet:", error);
+      throw error;
+    }
+  }
   /**
    * Get connection status
    */
@@ -23597,13 +23685,41 @@ var DoraCell = class {
     return this.connectionStatus;
   }
   /**
-   * Get available extensions
+   * Fetch available extensions (DID numbers) from the API
+   */
+  async fetchExtensions() {
+    if (!this.authProvider.isAuthenticated()) {
+      throw new Error("SDK not authenticated. Call initialize() first.");
+    }
+    try {
+      const response = await this.apiClient.get("/extensions");
+      const extensions = response.data || response.extensions || response;
+      if (this.credentials && Array.isArray(extensions)) {
+        this.credentials.extensions = extensions;
+      }
+      return Array.isArray(extensions) ? extensions : [];
+    } catch (error) {
+      console.error("SDK: Failed to fetch extensions:", error);
+      return this.credentials?.extensions || [];
+    }
+  }
+  /**
+   * Get available extensions (DID numbers)
    */
   getExtensions() {
-    if (!this.credentials?.extensions) {
-      return [];
+    return this.credentials?.extensions || [];
+  }
+  /**
+   * Update active extension and re-initialize SIP connection
+   */
+  async setExtension(extension) {
+    console.log(`SDK: Switching to extension ${extension}...`);
+    if (this.credentials) {
+      const domain = this.credentials.sipDomain || "cell.usedora.com";
+      this.credentials.sipUri = `sip:${extension}@${domain}`;
+      await this.initializeUserAgent();
+      this.emitConnectionStatus(this.connectionStatus);
     }
-    return this.credentials.extensions.map((ext) => ext.extension);
   }
   /**
    * Event listener management
@@ -23635,9 +23751,10 @@ var DoraCell = class {
   }
   // Helper methods
   emitConnectionStatus(error) {
+    const extension = this.credentials?.extensions?.[0]?.extension || (this.credentials?.sipUri ? extractNumberFromSipUri(this.credentials.sipUri) : void 0);
     const state = {
       status: this.connectionStatus,
-      extension: this.credentials?.extensions?.[0]?.extension,
+      extension,
       error
     };
     this.events.emit("connection:status", state);
@@ -23678,6 +23795,22 @@ var DoraCell = class {
       return v.toString(16);
     });
   }
+  resolveApiBaseUrl(config) {
+    if (config.apiBaseUrl) return config.apiBaseUrl;
+    if (config.environment) {
+      switch (config.environment) {
+        case "staging":
+        case "dev":
+          return "https://dev.api.cell.usedora.com/api";
+        case "production":
+          return "https://api.cell.usedora.com/api";
+      }
+    }
+    if (typeof process !== "undefined" && process.env?.NEXT_PUBLIC_BASE_API_URL) {
+      return process.env.NEXT_PUBLIC_BASE_API_URL;
+    }
+    return "https://api.cell.usedora.com/api";
+  }
 };
 
 exports.AuthenticationError = AuthenticationError;