@unboundcx/sdk 2.6.15 → 2.7.0

package/base.js

@@ -101,6 +101,14 @@ export class BaseSDK {
   removeTransport(name) {
     this.transports.delete(name);
   }
+  
+  _getJsonSafely(str, defaultValue) {
+    try {
+      return JSON.parse(str);
+    } catch (e) {
+      return defaultValue;
+    }
+  }
 
   async _getAvailableTransport(forceFetch = false) {
     if (forceFetch) {
@@ -174,9 +182,10 @@ export class BaseSDK {
 
     // Try transport plugins first
     const transport = await this._getAvailableTransport(forceFetch);
+    let response;
     if (transport) {
       try {
-        const result = await transport.request(endpoint, method, params, {
+        response = await transport.request(endpoint, method, params, {
           namespace: this.namespace,
           token: this.token,
           callId: this.callId,
@@ -184,13 +193,7 @@ export class BaseSDK {
           baseURL: this.baseURL || this.fullUrl,
         });
         
-        // Debug logging for transport plugins
-        if (this.debugMode) {
-          const status = result?.status || 200;
-          console.log(`API :: ${transport.name} :: ${method.toUpperCase()} :: ${endpoint} :: ${status}`);
-        }
         
-        return result;
       } catch (err) {
         // IMPORTANT: This catch block should ONLY handle transport-level failures
         // (e.g., WebSocket disconnected, plugin unavailable, network errors)
@@ -198,22 +201,22 @@ export class BaseSDK {
         // Transport plugins should:
         // - RETURN API error responses normally (400, 500, etc.) as response objects
         // - ONLY THROW for transport mechanism failures
-        //
-        // This ensures API errors are passed through unchanged, just like built-in fetch
         
-        if (this.debugMode) {
-          console.log(`API :: Transport ${transport.name} failure :: ${method.toUpperCase()} :: ${endpoint} :: ${err.message}`);
-        }
         console.warn(
           `Transport ${transport.name} mechanism failed, falling back to HTTP:`,
           err.message,
         );
-        // Fall through to built-in HTTP fetch
+
+        // Built-in HTTP transport (fallback)
+        return this._httpRequest(endpoint, method, params);
       }
+    } else {
+      // No transport available, fallback to HTTP
+      return this._httpRequest(endpoint, method, params);
     }
 
-    // Built-in HTTP transport (fallback)
-    return this._httpRequest(endpoint, method, params);
+    return this._processResponse(response, transport.name, method, endpoint);
+
   }
 
   _isMultipartBody(body) {
@@ -306,72 +309,102 @@ export class BaseSDK {
 
     const response = await fetch(url, options);
     
+    return this._processResponse(response, 'https', method, endpoint);
+    
+  }
+
+  async _processResponse(response, transport, method, endpoint) {
     // Check if the response indicates an HTTP error
     // These are API/configuration errors, not transport failures
     if (!response.ok) {
       let errorBody;
-      const contentType = response.headers.get('content-type') || '';
-      
-      try {
-        if (contentType.includes('application/json')) {
-          errorBody = await response.json();
-        } else {
-          errorBody = await response.text();
+      if (response?.body) {
+          errorBody = response.body;
+      } else if (response?.headers?.['content-type']) {
+        const contentType = response.headers['content-type'];
+        try {
+          if (typeof  response?.json === 'function' || typeof response?.text === 'function') {
+            if (contentType.includes('application/json')) {
+              errorBody = await response.json();
+            } else if (contentType.includes('text/')) {
+              errorBody = await response.text();
+            }
+          } else {
+            if (contentType.includes('application/json')) {
+              errorBody = this._getJsonSafely(response?.body, response?.body || {});
+            } else if (contentType.includes('text/')) {
+              errorBody = response?.body || '';
+            }
+          }
+          if (!errorBody) {
+            errorBody = `HTTP ${response.status} ${response.statusText}`;
+          }
+        } catch (parseError) {
+          errorBody = `HTTP ${response.status} ${response.statusText}`;
         }
-      } catch (parseError) {
+      } else {
         errorBody = `HTTP ${response.status} ${response.statusText}`;
       }
       
       // Create a structured error for API/HTTP failures
-      const httpError = new Error(`API :: Error :: https :: ${options.method} :: ${endpoint} :: ${response.status} :: ${response.statusText}`);
+      const httpError = new Error(`API :: Error :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response.status} :: ${response.statusText}`);
       httpError.status = response.status;
       httpError.statusText = response.statusText;
-      httpError.method = options.method;
+      httpError.method = method;
       httpError.endpoint = endpoint;
       httpError.body = errorBody;
+      httpError.message = errorBody?.error || errorBody?.message || 'API Error';
       
+          // Debug logging for successful HTTP requests
+    if (this.debugMode) {
+      console.log(`API :: ERROR :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status} :: ${responseRequestId}`, httpError);
+    }
+
       throw httpError;
     }
-    
-    // Check content type to determine how to parse successful response
-    const contentType = response.headers.get('content-type') || '';
-    let bodyResponse;
-    
-    if (contentType.includes('application/json')) {
-      bodyResponse = await response.json();
-    } else if (contentType.includes('text/')) {
-      bodyResponse = await response.text();
+
+    let responseBody;
+    if (response?.body) {
+        responseBody = response.body;
+    } else if (response?.headers?.['content-type']) {
+      const contentType = response.headers['content-type'];
+      try {
+        if (transport === 'https') {
+          if (contentType.includes('application/json')) {
+            responseBody = await response.json();
+          } else if (contentType.includes('text/')) {
+            responseBody = await response.text();
+          } else {
+            responseBody = await response.arrayBuffer();
+          }
+        } else {
+          if (contentType.includes('application/json')) {
+            responseBody = this._getJsonSafely(response.body, response.body);
+          } else if (contentType.includes('text/')) {
+            responseBody = response?.body || '';
+          }
+        }
+        if (!responseBody) {
+          responseBody = {};
+        }
+      } catch (parseError) {
+        responseBody = {};
+      }
     } else {
-      // For binary content (PDFs, images, etc), return as ArrayBuffer
-      bodyResponse = await response.arrayBuffer();
+      responseBody = {};
     }
-
+  
     const responseHeaders = response.headers;
     const responseRequestId =
       responseHeaders?.get?.('x-request-id') ||
       responseHeaders?.['x-request-id'];
 
-    if (!response.ok) {
-      // Debug logging for HTTP errors
-      if (this.debugMode) {
-        console.log(`API :: https :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status}`);
-      }
-      
-      throw {
-        name: `API :: Error :: https :: ${method} :: ${endpoint} :: ${responseRequestId} :: ${response?.status} :: ${response?.statusText}`,
-        message: bodyResponse?.message || `API Error occured.`,
-        method,
-        endpoint,
-        status: response?.status,
-        statusText: response?.statusText,
-      };
-    }
 
     // Debug logging for successful HTTP requests
     if (this.debugMode) {
-      console.log(`API :: https :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status}`);
+      console.log(`API :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status} :: ${responseRequestId}`);
     }
     
-    return bodyResponse;
+    return responseBody;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "2.6.15",
+  "version": "2.7.0",
   "description": "Official JavaScript SDK for the Unbound API - A comprehensive toolkit for integrating with Unbound's communication, AI, and data management services",
   "main": "index.js",
   "type": "module",

package/services/messaging.js

@@ -926,7 +926,7 @@ export class TenDlcBrandsService {
    * @param {Object} params - Brand parameters
    * @param {string} params.name - Brand display name (required)
    * @param {string} params.entityType - Entity type: PRIVATE_PROFIT, PUBLIC_PROFIT, NON_PROFIT (required)
-   * @param {string} [params.cspId] - CSP ID for resellers
+   * @param {string} [params.cspId] - CSP ID for resellers  
    * @param {string} params.companyName - Company name (required)
    * @param {string} [params.ein] - Employer Identification Number
    * @param {string} params.address1 - Street address (required)
@@ -1072,6 +1072,8 @@ export class TenDlcBrandsService {
    * @param {string} [params.state] - State
    * @param {string} [params.postalCode] - Postal code
    * @param {string} [params.country] - Country
+   * @param {string} [params.pocFirstName] - Point of contact first name
+   * @param {string} [params.pocLastName] - Point of contact last name
    * @param {string} [params.pocEmail] - Point of contact email
    * @param {string} [params.pocPhone] - Point of contact phone
    * @param {string} [params.stockSymbol] - Stock symbol for public companies
@@ -1082,7 +1084,7 @@ export class TenDlcBrandsService {
    * @param {string} [params.altBusinessIdType] - Alternative business ID type
    * @param {string} [params.brandRelationship] - Brand relationship
    * @param {string} [params.businessContactEmail] - Business contact email for 2025 compliance
-   * @param {string} [params.firstName] - First name for 2025 compliance
+   * @param {string} [params.firstName] - First name for 2025 compliance  
    * @param {string} [params.lastName] - Last name for 2025 compliance
    * @param {string} [params.mobilePhone] - Mobile phone for 2025 compliance
    * @returns {Promise<Object>} Updated brand details
@@ -1099,6 +1101,8 @@ export class TenDlcBrandsService {
     state,
     postalCode,
     country,
+    pocFirstName,
+    pocLastName,
     pocEmail,
     pocPhone,
     stockSymbol,
@@ -1128,6 +1132,8 @@ export class TenDlcBrandsService {
         state: { type: 'string', required: false },
         postalCode: { type: 'string', required: false },
         country: { type: 'string', required: false },
+        pocFirstName: { type: 'string', required: false },
+        pocLastName: { type: 'string', required: false },
         pocEmail: { type: 'string', required: false },
         pocPhone: { type: 'string', required: false },
         stockSymbol: { type: 'string', required: false },
@@ -1156,6 +1162,8 @@ export class TenDlcBrandsService {
     if (state !== undefined) updateData.state = state;
     if (postalCode !== undefined) updateData.postalCode = postalCode;
     if (country !== undefined) updateData.country = country;
+    if (pocFirstName !== undefined) updateData.pocFirstName = pocFirstName;
+    if (pocLastName !== undefined) updateData.pocLastName = pocLastName;
     if (pocEmail !== undefined) updateData.pocEmail = pocEmail;
     if (pocPhone !== undefined) updateData.pocPhone = pocPhone;
     if (stockSymbol !== undefined) updateData.stockSymbol = stockSymbol;