@scalekit-sdk/node 2.0.1 → 2.1.1

package/tests/scalekit.test.ts

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,168 @@
+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');
+    });
+  });
+}); 

package/tests/utils/test-data.ts

@@ -0,0 +1,314 @@
+import { CreateUserRequest, UpdateUserRequest } from '../../src/types/user';
+import { TemplateType } from '../../src/pkg/grpc/scalekit/v1/auth/passwordless_pb';
+import { DomainType } from '../../src/pkg/grpc/scalekit/v1/domains/domains_pb';
+
+/**
+ * Test data generation utilities to reduce redundancy across test files
+ */
+
+export class TestDataGenerator {
+  /**
+   * Generate a unique timestamp-based identifier
+   */
+  static generateUniqueId(): string {
+    return Date.now().toString();
+  }
+
+  /**
+   * Generate a unique email address for testing
+   */
+  static generateUniqueEmail(): string {
+    return `test.user.${this.generateUniqueId()}@example.com`;
+  }
+
+  /**
+   * Generate test organization data
+   */
+  static generateOrganizationData() {
+    const uniqueId = this.generateUniqueId();
+    return {
+      name: `Test Org ${uniqueId}`,
+      externalId: `ext_org_${uniqueId}`
+    };
+  }
+
+  /**
+   * Generate test user data
+   */
+  static generateUserData(overrides: Partial<CreateUserRequest> = {}): CreateUserRequest {
+    const uniqueEmail = this.generateUniqueEmail();
+    
+    return {
+      email: uniqueEmail,
+      userProfile: {
+        firstName: 'Test',
+        lastName: 'User'
+      },
+      metadata: {
+        source: 'test'
+      },
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test user update data
+   */
+  static generateUserUpdateData(overrides: Partial<UpdateUserRequest> = {}): UpdateUserRequest {
+    return {
+      userProfile: {
+        firstName: 'Updated',
+        lastName: 'Name'
+      },
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test passwordless email data
+   */
+  static generatePasswordlessEmailData(overrides: any = {}) {
+    return {
+      template: TemplateType.SIGNIN,
+      state: 'test-state',
+      expiresIn: 3600,
+      magiclinkAuthUri: 'https://example.com/auth/callback',
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test passwordless email with template variables
+   */
+  static generatePasswordlessEmailWithTemplateData(overrides: any = {}) {
+    return {
+      template: TemplateType.SIGNUP,
+      templateVariables: {
+        companyName: 'Test Company',
+        appName: 'Test App'
+      },
+      magiclinkAuthUri: 'https://example.com/auth/callback',
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test webhook data for verification
+   */
+  static generateWebhookData() {
+    const secret = 'whsec_test-secret';
+    const payload = '{"test": "data"}';
+    const timestamp = Math.floor(Date.now() / 1000).toString();
+    const webhookId = 'msg_test_webhook_id';
+    
+    // Generate valid signature for testing
+    const crypto = require('crypto');
+    const data = `${webhookId}.${timestamp}.${payload}`;
+    const hmac = crypto.createHmac('sha256', Buffer.from('test-secret', 'base64'));
+    hmac.update(data);
+    const computedSignature = hmac.digest('base64');
+    const signature = `v1,${computedSignature}`;
+    
+    return {
+      secret,
+      payload,
+      timestamp,
+      webhookId,
+      signature,
+      headers: {
+        'webhook-id': webhookId,
+        'webhook-timestamp': timestamp,
+        'webhook-signature': signature
+      }
+    };
+  }
+
+  /**
+   * Generate test authorization URL options
+   */
+  static generateAuthorizationUrlOptions(overrides: any = {}) {
+    return {
+      scopes: ['openid', 'profile'],
+      state: 'test-state',
+      nonce: 'test-nonce',
+      prompt: 'login',
+      ...overrides
+    };
+  }
+
+  /**
+   * Generate test PKCE parameters
+   */
+  static generatePKCEParams() {
+    return {
+      codeChallenge: 'test-challenge',
+      codeChallengeMethod: 'S256'
+    };
+  }
+
+  /**
+   * Generate test pagination parameters
+   */
+  static generatePaginationParams(pageSize: number = 10) {
+    return {
+      pageSize,
+      pageToken: ''
+    };
+  }
+
+  /**
+   * Generate test credential data for passwordless verification
+   */
+  static generateCredentialData(type: 'code' | 'linkToken' = 'code') {
+    if (type === 'code') {
+      return { code: 'mock-code' };
+    } else {
+      return { linkToken: 'mock-link-token' };
+    }
+  }
+
+  /**
+   * Generate test domain data
+   */
+  static generateDomainData(domainType?: 'allowed' | 'organization') {
+    const uniqueId = this.generateUniqueId();
+    const baseDomain = `test-domain-${uniqueId}.com`;
+    
+    return {
+      domain: baseDomain,
+      domainType: domainType === 'allowed' ? 'ALLOWED_EMAIL_DOMAIN' : 
+                  domainType === 'organization' ? 'ORGANIZATION_DOMAIN' : undefined
+    };
+  }
+
+  /**
+   * Generate unique domain name for testing
+   */
+  static generateUniqueDomainName(prefix: string = 'test'): string {
+    const uniqueId = this.generateUniqueId();
+    return `${prefix}-${uniqueId}.com`;
+  }
+}
+
+/**
+ * Test organization management utilities
+ */
+export class TestOrganizationManager {
+  /**
+   * Create a test organization and return its ID
+   */
+  static async createTestOrganization(client: any): Promise<string> {
+    const orgData = TestDataGenerator.generateOrganizationData();
+    const orgResponse = await client.organization.createOrganization(
+      orgData.name, 
+      { externalId: orgData.externalId }
+    );
+    
+    const testOrg = orgResponse.organization?.id || '';
+    if (!testOrg) {
+      throw new Error('Failed to create test organization');
+    }
+    
+    return testOrg;
+  }
+
+  /**
+   * Clean up a test organization
+   */
+  static async cleanupTestOrganization(client: any, testOrg: string): Promise<void> {
+    if (testOrg) {
+      try {
+        await client.organization.deleteOrganization(testOrg);
+      } catch (error) {
+        // Organization may already be deleted
+      }
+    }
+  }
+}
+
+/**
+ * Test user management utilities
+ */
+export class TestUserManager {
+  /**
+   * Create a test user and return user data
+   */
+  static async createTestUser(client: any, testOrg: string, overrides: Partial<CreateUserRequest> = {}) {
+    const userData = TestDataGenerator.generateUserData(overrides);
+    const createResponse = await client.user.createUserAndMembership(testOrg, userData);
+    const createdUserId = createResponse.user?.id;
+    
+    if (!createdUserId) {
+      throw new Error('Failed to create test user');
+    }
+    
+    return {
+      userId: createdUserId,
+      userData,
+      response: createResponse
+    };
+  }
+
+  /**
+   * Clean up a test user
+   */
+  static async cleanupTestUser(client: any, testOrg: string, userId: string): Promise<void> {
+    if (userId) {
+      try {
+        // Remove membership if it exists
+        await client.user.deleteMembership(testOrg, userId);
+      } catch (error) {
+        // Membership may not exist
+      }
+      
+      try {
+        await client.user.deleteUser(userId);
+      } catch (error) {
+        // User may already be deleted
+      }
+    }
+  }
+}
+
+/**
+ * Test domain management utilities
+ */
+export class TestDomainManager {
+  /**
+   * Create a test domain and return domain data
+   */
+  static async createTestDomain(client: any, testOrg: string, domainType?: 'allowed' | 'organization') {
+    const domainName = TestDataGenerator.generateUniqueDomainName();
+    const options = domainType ? { 
+      domainType: domainType === 'allowed' ? DomainType.ALLOWED_EMAIL_DOMAIN : DomainType.ORGANIZATION_DOMAIN
+    } : undefined;
+    
+    const response = await client.domain.createDomain(testOrg, domainName, options);
+    const createdDomainId = response.domain?.id;
+    
+    if (!createdDomainId) {
+      throw new Error('Failed to create test domain');
+    }
+    
+    return {
+      domainId: createdDomainId,
+      domainName,
+      domainType: response.domain?.domainType,
+      response
+    };
+  }
+
+  /**
+   * Clean up a test domain (if domain deletion is supported)
+   */
+  static async cleanupTestDomain(client: any, testOrg: string, domainId: string): Promise<void> {
+    if (domainId) {
+      try {
+        // Note: Domain deletion may not be implemented yet
+        // await client.domain.deleteDomain(testOrg, domainId);
+      } catch (error) {
+        // Domain may already be deleted or deletion not supported
+      }
+    }
+  }
+}