@scalekit-sdk/node 2.2.0 → 2.2.2

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/users.test.ts

@@ -1,168 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { CreateUserRequest, UpdateUserRequest } from '../src/types/user';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { TestDataGenerator, TestOrganizationManager, TestUserManager } from './utils/test-data';
-
-describe('Users', () => {
-  let client: ScalekitClient;
-  let testOrg: string;
-  let userId: string | null = null;
-  let sharedUserData: CreateUserRequest;
-
-  beforeEach(async () => {
-    // Use global client
-    client = global.client;
-    
-    // Create test organization for each test
-    testOrg = await TestOrganizationManager.createTestOrganization(client);
-    
-    // Create a shared user for testing
-    sharedUserData = TestDataGenerator.generateUserData();
-    const createResponse = await client.user.createUserAndMembership(testOrg, sharedUserData);
-    userId = createResponse.user?.id || null;
-    expect(userId).toBeDefined();
-  });
-
-  afterEach(async () => {
-    // Clean up test resources
-    if (userId) {
-      await TestUserManager.cleanupTestUser(client, testOrg, userId);
-      userId = null;
-    }
-    
-    // Clean up test organization
-    await TestOrganizationManager.cleanupTestOrganization(client, testOrg);
-  });
-
-  describe('listOrganizationUsers', () => {
-    it('should list users by organization', async () => {
-      // List users in the organization
-      const usersList = await client.user.listOrganizationUsers(testOrg, TestDataGenerator.generatePaginationParams());
-
-      expect(usersList).toBeDefined();
-      expect(usersList.users).toBeDefined();
-      expect(Array.isArray(usersList.users)).toBe(true);
-      expect(usersList.users.length).toBeGreaterThan(0);
-
-      // Verify basic user attributes
-      const firstUser = usersList.users[0];
-      expect(firstUser.id).toBeDefined();
-      expect(firstUser.email).toBeDefined();
-      expect(firstUser.environmentId).toBeDefined();
-    });
-
-    it('should handle pagination', async () => {
-      const firstPage = await client.user.listOrganizationUsers(testOrg, TestDataGenerator.generatePaginationParams(5));
-
-      expect(firstPage).toBeDefined();
-      expect(firstPage.users.length).toBeLessThanOrEqual(5);
-
-      if (firstPage.nextPageToken) {
-        const secondPage = await client.user.listOrganizationUsers(testOrg, {
-          pageSize: 5,
-          pageToken: firstPage.nextPageToken
-        });
-
-        expect(secondPage).toBeDefined();
-        expect(secondPage.users).toBeDefined();
-      }
-    });
-  });
-
-  describe('getUser', () => {
-    it('should get user by ID', async () => {
-      // Retrieve the user by ID
-      const user = await client.user.getUser(userId!);
-      
-      expect(user).toBeDefined();
-      expect(user.user).toBeDefined();
-      expect(user.user?.id).toBe(userId);
-      expect(user.user?.email).toBe(sharedUserData.email);
-    });
-  });
-
-  describe('createUserAndMembership', () => {
-    it('should create user and membership', async () => {
-      // Create a new user for this specific test
-      const userData = TestDataGenerator.generateUserData();
-      let newUserId: string | null = null;
-
-      try {
-        const response = await client.user.createUserAndMembership(testOrg, userData);
-        
-        expect(response).toBeDefined();
-        expect(response.user).toBeDefined();
-        expect(response.user?.id).toBeDefined();
-        expect(response.user?.email).toBe(userData.email);
-        expect(response.user?.metadata?.source).toBe('test');
-        
-        newUserId = response.user?.id || null;
-      } finally {
-        // Clean up the new user created in this test
-        if (newUserId) {
-          await TestUserManager.cleanupTestUser(client, testOrg, newUserId);
-        }
-      }
-    });
-
-    it('should throw error when email is missing', async () => {
-      const userData = TestDataGenerator.generateUserData({ email: '' }); // Empty email
-
-      await expect(
-        client.user.createUserAndMembership(testOrg, userData)
-      ).rejects.toThrow('email is required');
-    });
-
-    it('should throw error when organizationId is missing', async () => {
-      const userData = TestDataGenerator.generateUserData({ email: 'test@example.com' });
-
-      await expect(
-        client.user.createUserAndMembership('', userData)
-      ).rejects.toThrow('organizationId is required');
-    });
-  });
-
-  describe('updateUser', () => {
-    it('should update user', async () => {
-      // Modify the shared user
-      const updateData = TestDataGenerator.generateUserUpdateData();
-
-      const updatedUser = await client.user.updateUser(userId!, updateData);
-      
-      expect(updatedUser).toBeDefined();
-      expect(updatedUser.user).toBeDefined();
-      expect(updatedUser.user?.id).toBe(userId);
-      expect(updatedUser.user?.userProfile?.firstName).toBe('Updated');
-      expect(updatedUser.user?.userProfile?.lastName).toBe('Name');
-    });
-  });
-
-  describe('resendInvite', () => {
-    it('should resend invite to user', async () => {
-      // Resend invite to the shared user
-      const resendResponse = await client.user.resendInvite(testOrg, userId!);
-      
-      // Verify the response structure
-      expect(resendResponse).toBeDefined();
-      expect(resendResponse.invite).toBeDefined();
-      expect(resendResponse.invite?.userId).toBe(userId);
-      expect(resendResponse.invite?.organizationId).toBe(testOrg);
-      expect(resendResponse.invite?.status).toBe('PENDING_INVITE');
-      expect(resendResponse.invite?.createdAt).toBeDefined();
-      expect(resendResponse.invite?.expiresAt).toBeDefined();
-      expect(resendResponse.invite?.resentCount).toBe(1);
-    });
-
-    it('should throw error when organizationId is missing', async () => {
-      await expect(
-        client.user.resendInvite('', userId!)
-      ).rejects.toThrow('organizationId is required');
-    });
-
-    it('should throw error when userId is missing', async () => {
-      await expect(
-        client.user.resendInvite(testOrg, '')
-      ).rejects.toThrow('userId is required');
-    });
-  });
-});