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

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');
-    });
-  });
-}); 

package/tests/utils/test-data.ts

@@ -1,481 +0,0 @@
-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';
-import { CreateRole, UpdateRole, CreateOrganizationRole } from '../../src/pkg/grpc/scalekit/v1/roles/roles_pb';
-import { CreatePermission } from '../../src/pkg/grpc/scalekit/v1/roles/roles_pb';
-
-/**
- * Test data generation utilities to reduce redundancy across test files
- */
-
-export class TestDataGenerator {
-  /**
-   * Generate a unique timestamp-based identifier
-   */
-  static generateUniqueId(): string {
-    // Alphanumeric only (no hyphens), to satisfy backend regex constraints
-    const ts = Date.now().toString(36);
-    const rnd = Math.random().toString(36).substr(2, 9);
-    return `${ts}${rnd}`;
-  }
-
-  /**
-   * 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`;
-  }
-
-  /**
-   * Generate test role data
-   */
-  static generateRoleData(overrides: Partial<CreateRole> = {}): CreateRole {
-    const uniqueId = this.generateUniqueId();
-    
-    return new CreateRole({
-      name: `test_role_${uniqueId}`,
-      displayName: `Test Role ${uniqueId}`,
-      description: `Test role description ${uniqueId}`,
-      permissions: [], // Initialize empty permissions array
-      ...overrides
-    });
-  }
-
-  /**
-   * Generate test role update data
-   */
-  static generateRoleUpdateData(overrides: Partial<UpdateRole> = {}): UpdateRole {
-    const uniqueId = this.generateUniqueId();
-    
-    return new UpdateRole({
-      displayName: `Updated Role ${uniqueId}`,
-      description: `Updated role description ${uniqueId}`,
-      ...overrides
-    });
-  }
-
-  /**
-   * Generate test organization role data
-   */
-  static generateOrganizationRoleData(overrides: Partial<CreateOrganizationRole> = {}): CreateOrganizationRole {
-    const uniqueId = this.generateUniqueId();
-    
-    return new CreateOrganizationRole({
-      name: `test_org_role_${uniqueId}`,
-      displayName: `Test Organization Role ${uniqueId}`,
-      description: `Test organization role description ${uniqueId}`,
-      permissions: [], // Initialize empty permissions array
-      ...overrides
-    });
-  }
-
-  /**
-   * Generate test permission data
-   */
-  static generatePermissionData(overrides: Partial<CreatePermission> = {}): CreatePermission {
-    const uniqueId = this.generateUniqueId();
-    
-    return new CreatePermission({
-      name: `test_permission_${uniqueId}`,
-      description: `Test permission description ${uniqueId}`,
-      ...overrides
-    });
-  }
-}
-
-/**
- * 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
-      }
-    }
-  }
-}
-
-/**
- * Test role management utilities
- */
-export class TestRoleManager {
-  /**
-   * Create a test role and return role data
-   */
-  static async createTestRole(client: any, overrides: Partial<CreateRole> = {}) {
-    const roleData = TestDataGenerator.generateRoleData(overrides);
-    const response = await client.role.createRole(roleData);
-    const createdRoleName = response.role?.name;
-    
-    if (!createdRoleName) {
-      throw new Error('Failed to create test role');
-    }
-    
-    return {
-      roleName: createdRoleName,
-      roleData,
-      response
-    };
-  }
-
-  /**
-   * Clean up a test role
-   */
-  static async cleanupTestRole(client: any, roleName: string): Promise<void> {
-    if (roleName) {
-      try {
-        await client.role.deleteRole(roleName);
-      } catch (error) {
-        // Role may already be deleted
-      }
-    }
-  }
-
-  /**
-   * Create a test organization role and return role data
-   */
-  static async createTestOrganizationRole(client: any, testOrg: string, overrides: Partial<CreateOrganizationRole> = {}) {
-    const roleData = TestDataGenerator.generateOrganizationRoleData(overrides);
-    const response = await client.role.createOrganizationRole(testOrg, roleData);
-    const createdRoleName = response.role?.name;
-    
-    if (!createdRoleName) {
-      throw new Error('Failed to create test organization role');
-    }
-    
-    return {
-      roleName: createdRoleName,
-      roleData,
-      response
-    };
-  }
-
-  /**
-   * Clean up a test organization role
-   */
-  static async cleanupTestOrganizationRole(client: any, testOrg: string, roleName: string): Promise<void> {
-    if (roleName) {
-      try {
-        await client.role.deleteOrganizationRole(testOrg, roleName);
-      } catch (error) {
-        // Role may already be deleted
-      }
-    }
-  }
-}
-
-/**
- * Test permission management utilities
- */
-export class TestPermissionManager {
-  /**
-   * Create a test permission and return permission data
-   */
-  static async createTestPermission(client: any, overrides: Partial<CreatePermission> = {}) {
-    const permissionData = TestDataGenerator.generatePermissionData(overrides);
-    const response = await client.permission.createPermission(permissionData);
-    const createdPermissionName = response.permission?.name;
-    
-    if (!createdPermissionName) {
-      throw new Error('Failed to create test permission');
-    }
-    
-    return {
-      permissionName: createdPermissionName,
-      permissionData,
-      response
-    };
-  }
-
-  /**
-   * Clean up a test permission
-   */
-  static async cleanupTestPermission(client: any, permissionName: string): Promise<void> {
-    if (permissionName) {
-      try {
-        await client.permission.deletePermission(permissionName);
-      } catch (error) {
-        // Permission may already be deleted
-      }
-    }
-  }
-} 

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "noImplicitAny": false,
-    "target": "ES6",
-    "lib": ["ES2020"],
-    "module": "commonjs",
-    "declaration": true,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": true,
-    "outDir": "lib",
-    "strict": true,
-    "sourceMap": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "typeRoots": ["src/types", "node_modules/@types"],
-    "moduleResolution": "Node"
-  },
-  "include": ["src"],
-}