@scalekit-sdk/node 2.2.0-beta.1 → 2.2.1

package/tests/role.test.ts

@@ -1,323 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { TestDataGenerator, TestOrganizationManager, TestRoleManager } from './utils/test-data';
-
-describe('Roles', () => {
-  let client: ScalekitClient;
-  let testOrg: string;
-  let testRoleName: string | null = null;
-  let testOrgRoleName: string | null = null;
-
-  beforeEach(async () => {
-    // Use global client
-    client = global.client;
-    
-    // Create test organization for each test
-    testOrg = await TestOrganizationManager.createTestOrganization(client);
-  });
-
-  afterEach(async () => {
-    // Clean up test resources
-    if (testRoleName) {
-      await TestRoleManager.cleanupTestRole(client, testRoleName);
-      testRoleName = null;
-    }
-    
-    if (testOrgRoleName) {
-      await TestRoleManager.cleanupTestOrganizationRole(client, testOrg, testOrgRoleName);
-      testOrgRoleName = null;
-    }
-    
-    // Clean up test organization
-    await TestOrganizationManager.cleanupTestOrganization(client, testOrg);
-  });
-
-  describe('RoleClient', () => {
-    it('should have role client available', () => {
-      expect(client.role).toBeDefined();
-      expect(typeof client.role.createRole).toBe('function');
-      expect(typeof client.role.getRole).toBe('function');
-      expect(typeof client.role.listRoles).toBe('function');
-      expect(typeof client.role.updateRole).toBe('function');
-      expect(typeof client.role.deleteRole).toBe('function');
-      expect(typeof client.role.getRoleUsersCount).toBe('function');
-    });
-
-    it('should have organization role methods available', () => {
-      expect(typeof client.role.createOrganizationRole).toBe('function');
-      expect(typeof client.role.getOrganizationRole).toBe('function');
-      expect(typeof client.role.listOrganizationRoles).toBe('function');
-      expect(typeof client.role.updateOrganizationRole).toBe('function');
-      expect(typeof client.role.deleteOrganizationRole).toBe('function');
-      expect(typeof client.role.getOrganizationRoleUsersCount).toBe('function');
-      expect(typeof client.role.updateDefaultOrganizationRoles).toBe('function');
-      expect(typeof client.role.deleteOrganizationRoleBase).toBe('function');
-    });
-  });
-
-  describe('Role API Integration Tests', () => {
-    describe('createRole', () => {
-      it('should create a new role', async () => {
-        const roleData = TestDataGenerator.generateRoleData();
-        
-        const response = await client.role.createRole(roleData);
-        
-        expect(response).toBeDefined();
-        expect(response.role).toBeDefined();
-        expect(response.role?.name).toBe(roleData.name);
-        expect(response.role?.displayName).toBe(roleData.displayName);
-        expect(response.role?.description).toBe(roleData.description);
-        
-        testRoleName = response.role?.name || null;
-      });
-
-      it('should throw error when role name is missing', async () => {
-        const roleData = TestDataGenerator.generateRoleData({ name: '' });
-        
-        await expect(
-          client.role.createRole(roleData)
-        ).rejects.toThrow();
-      });
-    });
-
-    describe('listRoles', () => {
-      it('should list all roles', async () => {
-        const response = await client.role.listRoles();
-        
-        expect(response).toBeDefined();
-        expect(response.roles).toBeDefined();
-        expect(Array.isArray(response.roles)).toBe(true);
-      });
-    });
-
-    describe('getRole', () => {
-      it('should get role by name', async () => {
-        // Create a test role first
-        const roleData = TestDataGenerator.generateRoleData();
-        const createResponse = await client.role.createRole(roleData);
-        testRoleName = createResponse.role?.name || null;
-        
-        const response = await client.role.getRole(testRoleName!);
-        
-        expect(response).toBeDefined();
-        expect(response.role).toBeDefined();
-        expect(response.role?.name).toBe(testRoleName);
-        expect(response.role?.displayName).toBe(roleData.displayName);
-        expect(response.role?.description).toBe(roleData.description);
-      });
-
-      it('should throw error when role does not exist', async () => {
-        await expect(
-          client.role.getRole('non-existent-role')
-        ).rejects.toThrow();
-      });
-    });
-
-    describe('updateRole', () => {
-      it('should update an existing role', async () => {
-        // Create a test role first
-        const roleData = TestDataGenerator.generateRoleData();
-        const createResponse = await client.role.createRole(roleData);
-        testRoleName = createResponse.role?.name || null;
-        
-        const updateData = TestDataGenerator.generateRoleUpdateData();
-        const response = await client.role.updateRole(testRoleName!, updateData);
-        
-        expect(response).toBeDefined();
-        expect(response.role).toBeDefined();
-        expect(response.role?.name).toBe(testRoleName);
-        expect(response.role?.displayName).toBe(updateData.displayName);
-        expect(response.role?.description).toBe(updateData.description);
-      });
-
-      it('should throw error when updating non-existent role', async () => {
-        const updateData = TestDataGenerator.generateRoleUpdateData();
-        
-        await expect(
-          client.role.updateRole('non-existent-role', updateData)
-        ).rejects.toThrow();
-      });
-    });
-
-    describe('deleteRole', () => {
-      it('should delete an existing role', async () => {
-        // Create a test role first
-        const roleData = TestDataGenerator.generateRoleData();
-        const createResponse = await client.role.createRole(roleData);
-        const roleName = createResponse.role?.name || null;
-        
-        const response = await client.role.deleteRole(roleName!);
-        
-        expect(response).toBeDefined();
-        
-        // Verify role is deleted
-        await expect(
-          client.role.getRole(roleName!)
-        ).rejects.toThrow();
-      });
-    });
-
-    describe('getRoleUsersCount', () => {
-      it('should get user count for a role', async () => {
-        // Create a test role first
-        const roleData = TestDataGenerator.generateRoleData();
-        const createResponse = await client.role.createRole(roleData);
-        testRoleName = createResponse.role?.name || null;
-        
-        const response = await client.role.getRoleUsersCount(testRoleName!);
-        
-        expect(response).toBeDefined();
-        expect(Number(response.count)).toBeGreaterThanOrEqual(0);
-      });
-    });
-  });
-
-  describe('Organization Role API Integration Tests', () => {
-    describe('createOrganizationRole', () => {
-      it('should create a new organization role', async () => {
-        const roleData = TestDataGenerator.generateOrganizationRoleData();
-        
-        const response = await client.role.createOrganizationRole(testOrg, roleData);
-        
-        expect(response).toBeDefined();
-        expect(response.role).toBeDefined();
-        expect(response.role?.name).toBe(roleData.name);
-        expect(response.role?.displayName).toBe(roleData.displayName);
-        expect(response.role?.description).toBe(roleData.description);
-        expect(response.role?.isOrgRole).toBe(true);
-        
-        testOrgRoleName = response.role?.name || null;
-      });
-
-      it('should throw error when organizationId is missing', async () => {
-        const roleData = TestDataGenerator.generateOrganizationRoleData();
-        
-        await expect(
-          client.role.createOrganizationRole('', roleData)
-        ).rejects.toThrow();
-      });
-    });
-
-    describe('listOrganizationRoles', () => {
-      it('should list all organization roles', async () => {
-        // Create a test organization role first
-        const roleData = TestDataGenerator.generateOrganizationRoleData();
-        const createResponse = await client.role.createOrganizationRole(testOrg, roleData);
-        testOrgRoleName = createResponse.role?.name || null;
-        
-        const response = await client.role.listOrganizationRoles(testOrg);
-        
-        expect(response).toBeDefined();
-        expect(response.roles).toBeDefined();
-        expect(Array.isArray(response.roles)).toBe(true);
-        expect(response.roles.length).toBeGreaterThan(0);
-        
-        // Verify our test role is in the list
-        const testRole = response.roles.find(role => role.name === testOrgRoleName);
-        expect(testRole).toBeDefined();
-        expect(testRole?.isOrgRole).toBe(true);
-      });
-    });
-
-    describe('getOrganizationRole', () => {
-      it('should get organization role by name', async () => {
-        // Create a test organization role first
-        const roleData = TestDataGenerator.generateOrganizationRoleData();
-        const createResponse = await client.role.createOrganizationRole(testOrg, roleData);
-        testOrgRoleName = createResponse.role?.name || null;
-        
-        const response = await client.role.getOrganizationRole(testOrg, testOrgRoleName!);
-        
-        expect(response).toBeDefined();
-        expect(response.role).toBeDefined();
-        expect(response.role?.name).toBe(testOrgRoleName);
-        expect(response.role?.displayName).toBe(roleData.displayName);
-        expect(response.role?.isOrgRole).toBe(true);
-      });
-    });
-
-    describe('updateOrganizationRole', () => {
-      it('should update an existing organization role', async () => {
-        // Create a test organization role first
-        const roleData = TestDataGenerator.generateOrganizationRoleData();
-        const createResponse = await client.role.createOrganizationRole(testOrg, roleData);
-        testOrgRoleName = createResponse.role?.name || null;
-        
-        const updateData = TestDataGenerator.generateRoleUpdateData();
-        const response = await client.role.updateOrganizationRole(testOrg, testOrgRoleName!, updateData);
-        
-        expect(response).toBeDefined();
-        expect(response.role).toBeDefined();
-        expect(response.role?.name).toBe(testOrgRoleName);
-        expect(response.role?.displayName).toBe(updateData.displayName);
-        expect(response.role?.description).toBe(updateData.description);
-        expect(response.role?.isOrgRole).toBe(true);
-      });
-    });
-
-    describe('deleteOrganizationRole', () => {
-      it('should delete an existing organization role', async () => {
-        // Create a test organization role first
-        const roleData = TestDataGenerator.generateOrganizationRoleData();
-        const createResponse = await client.role.createOrganizationRole(testOrg, roleData);
-        const roleName = createResponse.role?.name || null;
-        
-        const response = await client.role.deleteOrganizationRole(testOrg, roleName!);
-        
-        expect(response).toBeDefined();
-        
-        // Verify role is deleted
-        await expect(
-          client.role.getOrganizationRole(testOrg, roleName!)
-        ).rejects.toThrow();
-      });
-    });
-
-    describe('getOrganizationRoleUsersCount', () => {
-      it('should get user count for an organization role', async () => {
-        // Create a test organization role first
-        const roleData = TestDataGenerator.generateOrganizationRoleData();
-        const createResponse = await client.role.createOrganizationRole(testOrg, roleData);
-        testOrgRoleName = createResponse.role?.name || null;
-        
-        const response = await client.role.getOrganizationRoleUsersCount(testOrg, testOrgRoleName!);
-        
-        expect(response).toBeDefined();
-        expect(Number(response.count)).toBeGreaterThanOrEqual(0);
-      });
-    });
-
-    describe('updateDefaultOrganizationRoles', () => {
-      it('should update default organization roles', async () => {
-        // Create a test organization role first
-        const roleData = TestDataGenerator.generateOrganizationRoleData();
-        const createResponse = await client.role.createOrganizationRole(testOrg, roleData);
-        testOrgRoleName = createResponse.role?.name || null;
-        
-        const response = await client.role.updateDefaultOrganizationRoles(testOrg, testOrgRoleName!);
-        
-        expect(response).toBeDefined();
-        expect(response.defaultMember).toBeDefined();
-        expect(response.defaultMember?.name).toBe(testOrgRoleName);
-      });
-    });
-
-    describe('deleteOrganizationRoleBase', () => {
-      it('should delete organization role base relationship', async () => {
-        // Create base org role
-        const baseRoleData = TestDataGenerator.generateOrganizationRoleData();
-        const baseResp = await client.role.createOrganizationRole(testOrg, baseRoleData);
-        const baseRoleName = baseResp.role?.name!;
-        
-        // Create extended org role which extends base
-        const extendedRoleData = TestDataGenerator.generateOrganizationRoleData({ extends: baseRoleName });
-        const extResp = await client.role.createOrganizationRole(testOrg, extendedRoleData);
-        testOrgRoleName = extResp.role?.name || null;
-        
-        const response = await client.role.deleteOrganizationRoleBase(testOrg, testOrgRoleName!);
-        
-        expect(response).toBeDefined();
-      });
-    });
-  });
-});

package/tests/scalekit.test.ts

@@ -1,104 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { AuthenticationOptions } from '../src/types/scalekit';
-import { describe, it, expect, beforeEach } from '@jest/globals';
-import { TestDataGenerator } from './utils/test-data';
-
-describe('ScalekitClient', () => {
-  let client: ScalekitClient;
-
-  beforeEach(() => {
-    // Use global client
-    client = global.client;
-  });
-
-  describe('constructor', () => {
-    it('should initialize with correct parameters', () => {
-      expect(client).toBeInstanceOf(ScalekitClient);
-      expect(client.organization).toBeDefined();
-      expect(client.user).toBeDefined();
-      expect(client.connection).toBeDefined();
-      expect(client.directory).toBeDefined();
-      expect(client.passwordless).toBeDefined();
-      expect(client.domain).toBeDefined();
-    });
-  });
-
-  describe('getAuthorizationUrl', () => {
-    it('should generate authorization URL with basic parameters', () => {
-      const redirectUri = 'https://example.com/callback';
-      const url = client.getAuthorizationUrl(redirectUri);
-      
-      expect(url).toContain('oauth/authorize');
-      expect(url).toContain(`redirect_uri=${encodeURIComponent(redirectUri)}`);
-      expect(url).toContain('response_type=code');
-    });
-
-    it('should include optional parameters when provided', () => {
-      const redirectUri = 'https://example.com/callback';
-      const options = TestDataGenerator.generateAuthorizationUrlOptions();
-      
-      const url = client.getAuthorizationUrl(redirectUri, options);
-      
-      expect(url).toContain('scope=openid%20profile');
-      expect(url).toContain('state=test-state');
-      expect(url).toContain('nonce=test-nonce');
-      expect(url).toContain('prompt=login');
-    });
-
-    it('should handle PKCE parameters', () => {
-      const redirectUri = 'https://example.com/callback';
-      const options = TestDataGenerator.generatePKCEParams();
-      
-      const url = client.getAuthorizationUrl(redirectUri, options);
-      
-      expect(url).toContain('code_challenge=test-challenge');
-      expect(url).toContain('code_challenge_method=S256');
-    });
-  });
-
-  describe('verifyWebhookPayload', () => {
-    it('should verify valid webhook payload', () => {
-      const webhookData = TestDataGenerator.generateWebhookData();
-      
-      const result = client.verifyWebhookPayload(webhookData.secret, webhookData.headers, webhookData.payload);
-      expect(result).toBe(true);
-    });
-
-    it('should throw error for invalid signature', () => {
-      const webhookData = TestDataGenerator.generateWebhookData();
-      
-      // Generate invalid signature using wrong payload data
-      const crypto = require('crypto');
-      const wrongData = `${webhookData.webhookId}.${webhookData.timestamp}.wrong-payload`;
-      const hmac = crypto.createHmac('sha256', Buffer.from('test-secret', 'base64'));
-      hmac.update(wrongData);
-      const wrongSignature = hmac.digest('base64');
-      const signature = `v1,${wrongSignature}`;
-      
-      const headers = {
-        'webhook-id': webhookData.webhookId,
-        'webhook-timestamp': webhookData.timestamp,
-        'webhook-signature': signature
-      };
-      
-      expect(() => {
-        client.verifyWebhookPayload(webhookData.secret, headers, webhookData.payload);
-      }).toThrow('Invalid Signature');
-    });
-  });
-
-  describe('validateAccessToken', () => {
-    it('should validate access token', async () => {
-      // Mock token for testing - expected to fail
-      const token = 'mock-token';
-      
-      try {
-        const result = await client.validateAccessToken(token);
-        expect(typeof result).toBe('boolean');
-      } catch (error) {
-        // Expected failure with mock token
-        expect(error).toBeDefined();
-      }
-    });
-  });
-}); 

package/tests/setup.ts

@@ -1,34 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import dotenv from 'dotenv';
-
-// Import Jest globals
-import { beforeAll } from '@jest/globals';
-
-// Load environment variables
-dotenv.config();
-
-// Global test configuration
-declare global {
-  var client: ScalekitClient;
-}
-
-beforeAll(() => {
-  // Validate required environment variables
-  const environmentUrl = process.env.SCALEKIT_ENVIRONMENT_URL;
-  const clientId = process.env.SCALEKIT_CLIENT_ID;
-  const clientSecret = process.env.SCALEKIT_CLIENT_SECRET;
-
-  // Check for required environment variables
-  if (!environmentUrl) {
-    throw new Error('SCALEKIT_ENVIRONMENT_URL environment variable is required');
-  }
-  if (!clientId) {
-    throw new Error('SCALEKIT_CLIENT_ID environment variable is required');
-  }
-  if (!clientSecret) {
-    throw new Error('SCALEKIT_CLIENT_SECRET environment variable is required');
-  }
-
-  // Initialize test client
-  global.client = new ScalekitClient(environmentUrl, clientId, clientSecret);
-}); 

package/tests/tools.test.ts

@@ -1,239 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { TestOrganizationManager } from './utils/test-data';
-
-describe('Tools', () => {
-  let client: ScalekitClient;
-  let testOrg: string;
-
-  beforeEach(async () => {
-    // Use global client
-    client = global.client;
-    
-    // Create test organization for each test
-    testOrg = await TestOrganizationManager.createTestOrganization(client);
-  });
-
-  afterEach(async () => {
-    // Clean up test organization
-    await TestOrganizationManager.cleanupTestOrganization(client, testOrg);
-  });
-
-  describe('listTools', () => {
-    it('should list tools', async () => {
-      const response = await client.tools.listTools();
-
-      expect(response).toBeDefined();
-      expect(response.tools).toBeDefined();
-      expect(Array.isArray(response.tools)).toBe(true);
-      expect(response.totalSize).toBeDefined();
-      expect(typeof response.totalSize).toBe('number');
-    });
-
-    it('should list tools with filter', async () => {
-      const response = await client.tools.listTools({
-        filter: {
-          provider: 'GOOGLE',
-        },
-      });
-
-      expect(response).toBeDefined();
-      expect(response.tools).toBeDefined();
-      expect(Array.isArray(response.tools)).toBe(true);
-    });
-
-    it('should list tools with pagination', async () => {
-      const firstPage = await client.tools.listTools({
-        pageSize: 10,
-      });
-
-      expect(firstPage).toBeDefined();
-      expect(firstPage.tools).toBeDefined();
-      expect(firstPage.tools.length).toBeLessThanOrEqual(10);
-
-      if (firstPage.nextPageToken) {
-        const secondPage = await client.tools.listTools({
-          pageSize: 10,
-          pageToken: firstPage.nextPageToken,
-        });
-
-        expect(secondPage).toBeDefined();
-        expect(secondPage.tools).toBeDefined();
-      }
-    });
-
-    it('should list tools with summary filter', async () => {
-      const response = await client.tools.listTools({
-        filter: {
-          summary: true,
-        },
-      });
-
-      expect(response).toBeDefined();
-      expect(response.toolNames).toBeDefined();
-      expect(Array.isArray(response.toolNames)).toBe(true);
-    });
-
-    it('should list tools with tool name filter', async () => {
-      const response = await client.tools.listTools({
-        filter: {
-          toolName: ['gmail_send_email'],
-        },
-      });
-
-      expect(response).toBeDefined();
-      expect(response.tools).toBeDefined();
-      expect(Array.isArray(response.tools)).toBe(true);
-    });
-  });
-
-  describe('listScopedTools', () => {
-    it('should list scoped tools with identifier', async () => {
-      const identifier = 'test_identifier';
-      
-      // Filter is required by the API and must have at least one non-empty array
-      try {
-        const response = await client.tools.listScopedTools(identifier, {
-          filter: {
-            providers: ['GOOGLE'],
-          },
-        });
-
-        expect(response).toBeDefined();
-        expect(response.tools).toBeDefined();
-        expect(Array.isArray(response.tools)).toBe(true);
-        expect(response.totalSize).toBeDefined();
-        expect(typeof response.totalSize).toBe('number');
-      } catch (error: any) {
-        // Expected errors: connected account not found, etc.
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should list scoped tools with filter', async () => {
-      const identifier = 'test_identifier';
-      
-      try {
-        const response = await client.tools.listScopedTools(identifier, {
-          filter: {
-            providers: ['GOOGLE'],
-            toolNames: ['gmail_send_email'],
-          },
-        });
-
-        expect(response).toBeDefined();
-        expect(response.tools).toBeDefined();
-        expect(Array.isArray(response.tools)).toBe(true);
-      } catch (error: any) {
-        // Expected errors: connected account not found, etc.
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should list scoped tools with pagination', async () => {
-      const identifier = 'test_identifier';
-      
-      // Filter is required by the API and must have at least one non-empty array
-      try {
-        const firstPage = await client.tools.listScopedTools(identifier, {
-          filter: {
-            providers: ['GOOGLE'],
-          },
-          pageSize: 10,
-        });
-
-        expect(firstPage).toBeDefined();
-        expect(firstPage.tools).toBeDefined();
-        expect(firstPage.tools.length).toBeLessThanOrEqual(10);
-
-        if (firstPage.nextPageToken) {
-          const secondPage = await client.tools.listScopedTools(identifier, {
-            filter: {
-              providers: ['GOOGLE'],
-            },
-            pageSize: 10,
-            pageToken: firstPage.nextPageToken,
-          });
-
-          expect(secondPage).toBeDefined();
-          expect(secondPage.tools).toBeDefined();
-        }
-      } catch (error: any) {
-        // Expected errors: connected account not found, etc.
-        expect(error).toBeDefined();
-      }
-    });
-  });
-
-  describe('executeTool', () => {
-    it('should handle execute tool request with minimal params', async () => {
-      // This test expects an error since we don't have a real tool/connected account
-      // but it validates the request structure is correct
-      try {
-        await client.tools.executeTool({
-          toolName: 'test_tool',
-          params: {
-            test: 'value',
-          },
-        });
-        // If execution succeeds, that's fine too
-      } catch (error: any) {
-        // Expected errors: tool not found, connected account not found, etc.
-        expect(error).toBeDefined();
-        // Verify it's a proper error response, not a request structure issue
-        expect(error.message || error.toString()).toBeDefined();
-      }
-    });
-
-    it('should handle execute tool with connected account ID', async () => {
-      try {
-        await client.tools.executeTool({
-          toolName: 'test_tool',
-          connectedAccountId: 'ca_test123',
-          params: {
-            test: 'value',
-          },
-        });
-      } catch (error: any) {
-        // Expected errors: tool not found, connected account not found, etc.
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should handle execute tool with identifier and connector', async () => {
-      try {
-        await client.tools.executeTool({
-          toolName: 'test_tool',
-          identifier: 'test@example.com',
-          connector: 'google_workspace',
-          organizationId: testOrg,
-          params: {
-            test: 'value',
-          },
-        });
-      } catch (error: any) {
-        // Expected errors: tool not found, connected account not found, etc.
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should handle execute tool with complex params', async () => {
-      try {
-        await client.tools.executeTool({
-          toolName: 'gmail_send_email',
-          identifier: 'test@example.com',
-          connector: 'google_workspace',
-          params: {
-            to: 'recipient@example.com',
-            subject: 'Test Subject',
-            body: 'Test Body',
-            attachments: [],
-          },
-        });
-      } catch (error: any) {
-        // Expected errors: tool not found, connected account not found, etc.
-        expect(error).toBeDefined();
-      }
-    });
-  });
-});