@dora-cell/sdk 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -22999,43 +22999,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) {
@@ -23047,28 +23045,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
@@ -23076,64 +23084,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
@@ -23407,6 +23393,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) {
@@ -23424,6 +23468,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:*");
     }
@@ -23433,7 +23479,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();
@@ -23586,6 +23645,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
    */
@@ -23593,13 +23681,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
@@ -23631,9 +23747,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);
@@ -23674,6 +23791,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";
+  }
 };
 
 export { AuthenticationError, CallError, CallSession, ConnectionError, DoraCell, DoraCellError, DoraCell as default, extractNumberFromSipUri, formatPhoneToSIP, isValidPhoneNumber, normalizePhoneNumber };