@unboundcx/sdk 1.0.0

package/services/workflows.js

@@ -0,0 +1,291 @@
+export class WorkflowsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.items = new WorkflowItemsService(sdk);
+    this.connections = new WorkflowConnectionsService(sdk);
+    this.sessions = new WorkflowSessionsService(sdk);
+  }
+
+  async getSettings(type) {
+    this.sdk.validateParams(
+      { type },
+      {
+        type: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: { type },
+    };
+
+    const result = await this.sdk._fetch('/workflows/settings', 'GET', params);
+    return result;
+  }
+}
+
+export class WorkflowItemsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async delete(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: {
+        where: {
+          id
+        }
+      }
+    }
+
+    const result = await this.sdk._fetch('/object/workflowItems', 'DELETE', params);
+    return result;
+  }
+
+  async list(workflowVersionId) {
+    this.sdk.validateParams(
+      { workflowVersionId },
+      {
+        workflowVersionId: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      query: {
+        expandDetails: true,
+        workflowVersionId
+      },
+    }
+
+    const result = await this.sdk._fetch('/object/workflowItems', 'GET', params);
+    return result;
+  }
+
+  async get(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    return this.sdk.objects.byId(id);
+  }
+
+  async create({ workflowVersionId, category, type, description, position, settings }) {
+    this.sdk.validateParams(
+      { workflowVersionId, category, type },
+      {
+        workflowVersionId: { type: 'string', required: true },
+        category: { type: 'string', required: true },
+        type: { type: 'string', required: true },
+        description: { type: 'string', required: false },
+        position: { type: 'object', required: false },
+        settings: { type: 'object', required: false },
+      },
+    );
+
+    const params = {
+      body: {
+        workflowVersionId,
+        category,
+        type,
+        description,
+        position,
+        settings,
+      },
+    }
+
+    const result = await this.sdk._fetch('/object/workflowItems', 'POST', params);
+    return result;
+  }
+
+  async update({ 
+    id, 
+    description, 
+    label, 
+    labelBgColor, 
+    labelTextColor, 
+    descriptionBgColor, 
+    descriptionTextColor, 
+    icon, 
+    iconBgColor, 
+    iconTextColor, 
+    ports, 
+    connections, 
+    position, 
+    settings 
+  }) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+        description: { type: 'string', required: false },
+        label: { type: 'string', required: false },
+        labelBgColor: { type: 'string', required: false },
+        labelTextColor: { type: 'string', required: false },
+        descriptionBgColor: { type: 'string', required: false },
+        descriptionTextColor: { type: 'string', required: false },
+        icon: { type: 'string', required: false },
+        iconBgColor: { type: 'string', required: false },
+        iconTextColor: { type: 'string', required: false },
+        ports: { type: 'array', required: false },
+        connections: { type: 'object', required: false },
+        position: { type: 'object', required: false },
+        settings: { type: 'object', required: false }
+      },
+    );
+
+    const updateData = {};
+    if (description !== undefined) updateData.description = description;
+    if (label !== undefined) updateData.label = label;
+    if (labelBgColor !== undefined) updateData.labelBgColor = labelBgColor;
+    if (labelTextColor !== undefined) updateData.labelTextColor = labelTextColor;
+    if (descriptionBgColor !== undefined) updateData.descriptionBgColor = descriptionBgColor;
+    if (descriptionTextColor !== undefined) updateData.descriptionTextColor = descriptionTextColor;
+    if (icon !== undefined) updateData.icon = icon;
+    if (iconBgColor !== undefined) updateData.iconBgColor = iconBgColor;
+    if (iconTextColor !== undefined) updateData.iconTextColor = iconTextColor;
+    if (ports !== undefined) updateData.ports = ports;
+    if (position !== undefined) updateData.position = position;
+    if (settings !== undefined) updateData.settings = settings;
+
+    const params = {
+      body: {
+        where: {
+          id
+        },
+        update: updateData
+      },
+    }
+
+    const result = await this.sdk._fetch('/object/workflowItems', 'PUT', params);
+    return result;
+  }
+}
+
+export class WorkflowConnectionsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async delete(workflowItemId, workflowItemPortId, inWorkflowItemId, inWorkflowItemPortId) {
+    this.sdk.validateParams(
+      { workflowItemId, workflowItemPortId, inWorkflowItemId, inWorkflowItemPortId },
+      {
+        workflowItemId: { type: 'string', required: true },
+        workflowItemPortId: { type: 'string', required: true },
+        inWorkflowItemId: { type: 'string', required: true },
+        inWorkflowItemPortId: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: {
+        where: {
+          workflowItemId,
+          workflowItemPortId,
+          inWorkflowItemId,
+          inWorkflowItemPortId
+        }
+      }
+    }
+
+    const result = await this.sdk._fetch('/object/workflowItemConnections', 'DELETE', params);
+    return result;
+  }
+
+  async create({ workflowItemPortId, workflowItemId, inWorkflowItemId, inWorkflowItemPortId }) {
+    this.sdk.validateParams(
+      { workflowItemPortId, workflowItemId, inWorkflowItemId, inWorkflowItemPortId },
+      {
+        workflowItemPortId: { type: 'string', required: true },
+        workflowItemId: { type: 'string', required: true },
+        inWorkflowItemId: { type: 'string', required: true },
+        inWorkflowItemPortId: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: {
+        workflowItemPortId, 
+        workflowItemId, 
+        inWorkflowItemId, 
+        inWorkflowItemPortId
+      },
+    }
+
+    const result = await this.sdk._fetch('/object/workflowItemConnections', 'POST', params);
+    return result;
+  }
+}
+
+export class WorkflowSessionsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async create(workflowId, sessionData) {
+    this.sdk.validateParams(
+      { workflowId, sessionData },
+      {
+        workflowId: { type: 'string', required: true },
+        sessionData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: sessionData,
+    };
+
+    const result = await this.sdk._fetch(`/workflows/${workflowId}/sessions`, 'POST', params);
+    return result;
+  }
+
+  async get(sessionId) {
+    this.sdk.validateParams(
+      { sessionId },
+      {
+        sessionId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/workflows/sessions/${sessionId}`, 'GET');
+    return result;
+  }
+
+  async update(sessionId, updateData) {
+    this.sdk.validateParams(
+      { sessionId, updateData },
+      {
+        sessionId: { type: 'string', required: true },
+        updateData: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: updateData,
+    };
+
+    const result = await this.sdk._fetch(`/workflows/sessions/${sessionId}`, 'PUT', params);
+    return result;
+  }
+
+  async delete(sessionId) {
+    this.sdk.validateParams(
+      { sessionId },
+      {
+        sessionId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/workflows/sessions/${sessionId}`, 'DELETE');
+    return result;
+  }
+}

package/test-backwards-compatibility.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+/*
+ * Backwards Compatibility Test
+ * 
+ * This script tests that the new modular SDK is backwards compatible
+ * with the existing monolithic SDK usage patterns.
+ */
+
+import SDK from './index.js';
+
+async function testBasicSDKFunctionality() {
+  console.log('🧪 Testing basic SDK functionality...');
+  
+  // Test SDK initialization (same as original)
+  const api = new SDK('test-namespace', 'call-123', 'fake-jwt-token', 'request-456');
+  
+  // Verify all main services are available
+  const expectedServices = [
+    'login', 'objects', 'messaging', 'video', 'voice', 'ai', 'lookup',
+    'layouts', 'subscriptions', 'workflows', 'notes', 'storage',
+    'verification', 'portals', 'sipEndpoints', 'externalOAuth',
+    'googleCalendar', 'enroll'
+  ];
+  
+  for (const service of expectedServices) {
+    if (!api[service]) {
+      throw new Error(`❌ Service '${service}' not found on SDK instance`);
+    }
+    console.log(`✅ Service '${service}' is available`);
+  }
+  
+  // Test nested services
+  if (!api.messaging.sms) {
+    throw new Error('❌ messaging.sms not found');
+  }
+  console.log('✅ messaging.sms is available');
+  
+  if (!api.messaging.email) {
+    throw new Error('❌ messaging.email not found');
+  }
+  console.log('✅ messaging.email is available');
+  
+  if (!api.ai.generative) {
+    throw new Error('❌ ai.generative not found');
+  }
+  console.log('✅ ai.generative is available');
+  
+  if (!api.workflows.items) {
+    throw new Error('❌ workflows.items not found');
+  }
+  console.log('✅ workflows.items is available');
+  
+  console.log('✅ All services are properly available');
+}
+
+function testSDKMethods() {
+  console.log('🧪 Testing SDK method signatures...');
+  
+  const api = new SDK('test-namespace');
+  
+  // Test that all expected methods exist with correct signatures
+  const methodTests = [
+    // Login service
+    { path: 'login.login', params: ['username', 'password'] },
+    { path: 'login.logout', params: [] },
+    { path: 'login.validate', params: [] },
+    
+    // Objects service  
+    { path: 'objects.byId', params: ['id', 'query'] },
+    { path: 'objects.query', params: ['object', 'query'] },
+    { path: 'objects.create', params: ['object', 'body'] },
+    { path: 'objects.updateById', params: ['object', 'id', 'update'] },
+    
+    // Messaging service
+    { path: 'messaging.sms.send', params: [{}] },
+    { path: 'messaging.email.send', params: [{}] },
+    
+    // Video service
+    { path: 'video.createRoom', params: [{}] },
+    { path: 'video.joinRoom', params: ['room', 'password', 'email'] },
+    
+    // AI service
+    { path: 'ai.generative.chat', params: [{}] },
+    { path: 'ai.tts.create', params: [{}] },
+  ];
+  
+  for (const test of methodTests) {
+    const pathParts = test.path.split('.');
+    let obj = api;
+    
+    for (const part of pathParts) {
+      if (!obj[part]) {
+        throw new Error(`❌ Method '${test.path}' not found`);
+      }
+      obj = obj[part];
+    }
+    
+    if (typeof obj !== 'function') {
+      throw new Error(`❌ '${test.path}' is not a function`);
+    }
+    
+    console.log(`✅ Method '${test.path}' exists and is a function`);
+  }
+}
+
+function testSDKExtensibility() {
+  console.log('🧪 Testing SDK extensibility...');
+  
+  const api = new SDK('test-namespace');
+  
+  // Test plugin system
+  const testPlugin = {
+    install: (sdk) => {
+      sdk.testPluginFeature = () => 'plugin-working';
+    }
+  };
+  
+  api.use(testPlugin);
+  
+  if (!api.testPluginFeature) {
+    throw new Error('❌ Plugin system not working');
+  }
+  
+  if (api.testPluginFeature() !== 'plugin-working') {
+    throw new Error('❌ Plugin not properly installed');
+  }
+  
+  console.log('✅ Plugin system working correctly');
+  
+  // Test extension system
+  class TestExtension {
+    constructor(sdk) {
+      this.testExtensionMethod = () => 'extension-working';
+    }
+  }
+  
+  api.extend(TestExtension);
+  
+  if (!api.testExtensionMethod) {
+    throw new Error('❌ Extension system not working');
+  }
+  
+  if (api.testExtensionMethod() !== 'extension-working') {
+    throw new Error('❌ Extension not properly installed');
+  }
+  
+  console.log('✅ Extension system working correctly');
+}
+
+function testClientServerCompatibility() {
+  console.log('🧪 Testing client/server environment compatibility...');
+  
+  // Test server-side initialization
+  const serverApi = new SDK('test-namespace', 'call-123', 'jwt-token', 'request-456');
+  
+  if (serverApi.environment !== 'node') {
+    console.log('⚠️  Expected Node.js environment, this might be running in browser');
+  }
+  
+  // Test client-side style initialization
+  const clientApi = new SDK('test-namespace', null, null, null, 'api.example.com');
+  
+  console.log('✅ Both server and client initialization patterns work');
+}
+
+async function runAllTests() {
+  console.log('🚀 Starting backwards compatibility tests...\n');
+  
+  try {
+    await testBasicSDKFunctionality();
+    console.log('');
+    
+    testSDKMethods();
+    console.log('');
+    
+    testSDKExtensibility();
+    console.log('');
+    
+    testClientServerCompatibility();
+    console.log('');
+    
+    console.log('🎉 All backwards compatibility tests passed!');
+    console.log('✅ The new modular SDK is fully backwards compatible');
+    
+  } catch (error) {
+    console.error('💥 Test failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run tests if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runAllTests();
+}