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

package/tests/domain.test.ts

@@ -1,293 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { DomainType } from '../src/pkg/grpc/scalekit/v1/domains/domains_pb';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { TestDataGenerator, TestOrganizationManager, TestDomainManager } from './utils/test-data';
-
-describe('Domains', () => {
-  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('createDomain', () => {
-    it('should create domain without domainType (backward compatibility)', async () => {
-      const domainName = TestDataGenerator.generateUniqueDomainName('backward-compat');
-      
-      const response = await client.domain.createDomain(testOrg, domainName);
-      
-      expect(response).toBeDefined();
-      expect(response.domain).toBeDefined();
-      expect(response.domain?.domain).toBe(domainName);
-      expect(response.domain?.id).toBeDefined();
-      expect(response.domain?.organizationId).toBe(testOrg);
-    });
-
-    it('should create domain with ALLOWED_EMAIL_DOMAIN type', async () => {
-      const domainName = TestDataGenerator.generateUniqueDomainName('allowed-email');
-      
-      const response = await client.domain.createDomain(testOrg, domainName, {
-        domainType: DomainType.ALLOWED_EMAIL_DOMAIN
-      });
-      
-      expect(response).toBeDefined();
-      expect(response.domain).toBeDefined();
-      expect(response.domain?.domain).toBe(domainName);
-      expect(response.domain?.domainType).toBe(DomainType.ALLOWED_EMAIL_DOMAIN);
-      expect(response.domain?.id).toBeDefined();
-      expect(response.domain?.organizationId).toBe(testOrg);
-    });
-
-    it('should create domain with ORGANIZATION_DOMAIN type', async () => {
-      const domainName = TestDataGenerator.generateUniqueDomainName('org-domain');
-      
-      const response = await client.domain.createDomain(testOrg, domainName, {
-        domainType: DomainType.ORGANIZATION_DOMAIN
-      });
-      
-      expect(response).toBeDefined();
-      expect(response.domain).toBeDefined();
-      expect(response.domain?.domain).toBe(domainName);
-      expect(response.domain?.domainType).toBe(DomainType.ORGANIZATION_DOMAIN);
-      expect(response.domain?.id).toBeDefined();
-      expect(response.domain?.organizationId).toBe(testOrg);
-    });
-
-    it('should create multiple domains of different types', async () => {
-      const allowedDomainName = TestDataGenerator.generateUniqueDomainName('allowed');
-      const orgDomainName = TestDataGenerator.generateUniqueDomainName('org');
-      
-      // Create allowed email domain
-      const allowedResponse = await client.domain.createDomain(testOrg, allowedDomainName, {
-        domainType: DomainType.ALLOWED_EMAIL_DOMAIN
-      });
-      
-      // Create organization domain
-      const orgResponse = await client.domain.createDomain(testOrg, orgDomainName, {
-        domainType: DomainType.ORGANIZATION_DOMAIN
-      });
-      
-      expect(allowedResponse.domain?.domainType).toBe(DomainType.ALLOWED_EMAIL_DOMAIN);
-      expect(orgResponse.domain?.domainType).toBe(DomainType.ORGANIZATION_DOMAIN);
-      expect(allowedResponse.domain?.domain).toBe(allowedDomainName);
-      expect(orgResponse.domain?.domain).toBe(orgDomainName);
-    });
-
-    it('should create domain using TestDomainManager utility', async () => {
-      const { domainId, domainName, domainType, response } = await TestDomainManager.createTestDomain(
-        client, 
-        testOrg, 
-        'allowed'
-      );
-      
-      expect(domainId).toBeDefined();
-      expect(domainName).toBeDefined();
-      expect(domainType).toBe(DomainType.ALLOWED_EMAIL_DOMAIN);
-      expect(response.domain?.domain).toBe(domainName);
-    });
-  });
-
-  describe('listDomains', () => {
-    it('should list domains for organization', async () => {
-      // Create a test domain first
-      const { domainName } = await TestDomainManager.createTestDomain(client, testOrg, 'allowed');
-      
-      const response = await client.domain.listDomains(testOrg);
-      
-      expect(response).toBeDefined();
-      expect(response.domains).toBeDefined();
-      expect(Array.isArray(response.domains)).toBe(true);
-      expect(response.domains.length).toBeGreaterThan(0);
-      
-      // Verify basic domain attributes
-      const firstDomain = response.domains[0];
-      expect(firstDomain.id).toBeDefined();
-      expect(firstDomain.domain).toBeDefined();
-      expect(firstDomain.organizationId).toBe(testOrg);
-    });
-
-    it('should return empty list when no domains exist', async () => {
-      // Use a fresh organization without any domains
-      const freshOrg = await TestOrganizationManager.createTestOrganization(client);
-      
-      try {
-        const response = await client.domain.listDomains(freshOrg);
-        
-        expect(response).toBeDefined();
-        expect(response.domains).toBeDefined();
-        expect(Array.isArray(response.domains)).toBe(true);
-        expect(response.domains.length).toBe(0);
-      } finally {
-        await TestOrganizationManager.cleanupTestOrganization(client, freshOrg);
-      }
-    });
-
-    it('should list domains with different types', async () => {
-      // Create domains of different types
-      const { domainName: allowedDomainName } = await TestDomainManager.createTestDomain(client, testOrg, 'allowed');
-      const { domainName: orgDomainName } = await TestDomainManager.createTestDomain(client, testOrg, 'organization');
-      
-      const response = await client.domain.listDomains(testOrg);
-      
-      expect(response.domains.length).toBeGreaterThanOrEqual(2);
-      
-      const domainNames = response.domains.map(d => d.domain);
-      const domainTypes = response.domains.map(d => d.domainType);
-      
-      expect(domainNames).toContain(allowedDomainName);
-      expect(domainNames).toContain(orgDomainName);
-      expect(domainTypes).toContain(DomainType.ALLOWED_EMAIL_DOMAIN);
-      expect(domainTypes).toContain(DomainType.ORGANIZATION_DOMAIN);
-    });
-
-    it('should list domains filtered by ALLOWED_EMAIL_DOMAIN type', async () => {
-      // Create domains of different types
-      const { domainName: allowedDomainName } = await TestDomainManager.createTestDomain(client, testOrg, 'allowed');
-      const { domainName: orgDomainName } = await TestDomainManager.createTestDomain(client, testOrg, 'organization');
-      
-      // Filter by ALLOWED_EMAIL_DOMAIN type
-      const response = await client.domain.listDomains(testOrg, {
-        domainType: DomainType.ALLOWED_EMAIL_DOMAIN
-      });
-      
-      expect(response).toBeDefined();
-      expect(response.domains).toBeDefined();
-      expect(Array.isArray(response.domains)).toBe(true);
-      
-      // Verify all returned domains are of type ALLOWED_EMAIL_DOMAIN
-      response.domains.forEach(domain => {
-        expect(domain.domainType).toBe(DomainType.ALLOWED_EMAIL_DOMAIN);
-      });
-      
-      // Verify the allowed domain is in the filtered list
-      const domainNames = response.domains.map(d => d.domain);
-      expect(domainNames).toContain(allowedDomainName);
-      
-      // Verify the organization domain is NOT in the filtered list
-      expect(domainNames).not.toContain(orgDomainName);
-    });
-
-    it('should list domains filtered by ORGANIZATION_DOMAIN type', async () => {
-      // Create domains of different types
-      const { domainName: allowedDomainName } = await TestDomainManager.createTestDomain(client, testOrg, 'allowed');
-      const { domainName: orgDomainName } = await TestDomainManager.createTestDomain(client, testOrg, 'organization');
-      
-      // Filter by ORGANIZATION_DOMAIN type
-      const response = await client.domain.listDomains(testOrg, {
-        domainType: DomainType.ORGANIZATION_DOMAIN
-      });
-      
-      expect(response).toBeDefined();
-      expect(response.domains).toBeDefined();
-      expect(Array.isArray(response.domains)).toBe(true);
-      
-      // Verify all returned domains are of type ORGANIZATION_DOMAIN
-      response.domains.forEach(domain => {
-        expect(domain.domainType).toBe(DomainType.ORGANIZATION_DOMAIN);
-      });
-      
-      // Verify the organization domain is in the filtered list
-      const domainNames = response.domains.map(d => d.domain);
-      expect(domainNames).toContain(orgDomainName);
-      
-      // Verify the allowed domain is NOT in the filtered list
-      expect(domainNames).not.toContain(allowedDomainName);
-    });
-  });
-
-  describe('getDomain', () => {
-    it('should get domain by ID successfully', async () => {
-      // Create a test domain first
-      const { domainId, domainName } = await TestDomainManager.createTestDomain(client, testOrg, 'allowed');
-      
-      const response = await client.domain.getDomain(testOrg, domainId);
-      
-      expect(response).toBeDefined();
-      expect(response.domain).toBeDefined();
-      expect(response.domain?.id).toBe(domainId);
-      expect(response.domain?.domain).toBe(domainName);
-      expect(response.domain?.organizationId).toBe(testOrg);
-    });
-
-    it('should throw error for non-existent domain', async () => {
-      const nonExistentDomainId = 'non-existent-domain-id';
-      
-      await expect(
-        client.domain.getDomain(testOrg, nonExistentDomainId)
-      ).rejects.toThrow();
-    });
-
-    it('should throw error for invalid organization ID', async () => {
-      // Create a test domain first
-      const { domainId } = await TestDomainManager.createTestDomain(client, testOrg, 'allowed');
-      const invalidOrgId = 'invalid-org-id';
-      
-      await expect(
-        client.domain.getDomain(invalidOrgId, domainId)
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('deleteDomain', () => {
-    it('should delete domain successfully', async () => {
-      // Create a test domain for deletion
-      const { domainId, domainName } = await TestDomainManager.createTestDomain(client, testOrg, 'allowed');
-      
-      // Verify domain exists before deletion
-      const getResponse = await client.domain.getDomain(testOrg, domainId);
-      expect(getResponse.domain?.id).toBe(domainId);
-      
-      // Delete the domain
-      const deleteResponse = await client.domain.deleteDomain(testOrg, domainId);
-      expect(deleteResponse).toBeDefined();
-      
-      // Verify domain is deleted by trying to get it
-      await expect(
-        client.domain.getDomain(testOrg, domainId)
-      ).rejects.toThrow();
-    });
-
-    it('should throw error when deleting non-existent domain', async () => {
-      const nonExistentDomainId = 'non-existent-domain-id';
-      
-      await expect(
-        client.domain.deleteDomain(testOrg, nonExistentDomainId)
-      ).rejects.toThrow();
-    });
-
-
-  });
-
-  describe('error handling', () => {
-    it('should handle invalid organization ID', async () => {
-      const invalidOrgId = 'invalid-org-id';
-      const domainName = TestDataGenerator.generateUniqueDomainName('error-test');
-      
-      await expect(
-        client.domain.createDomain(invalidOrgId, domainName)
-      ).rejects.toThrow();
-      
-      await expect(
-        client.domain.listDomains(invalidOrgId)
-      ).rejects.toThrow();
-    });
-
-    it('should handle invalid domain name format', async () => {
-      const invalidDomainName = 'invalid-domain-name';
-      
-      await expect(
-        client.domain.createDomain(testOrg, invalidDomainName)
-      ).rejects.toThrow();
-    });
-  });
-}); 

package/tests/organization.test.ts

@@ -1,81 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { TestDataGenerator, TestOrganizationManager } from './utils/test-data';
-
-describe('Organizations', () => {
-  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('listOrganization', () => {
-    it('should list organizations', async () => {
-      const organizations = await client.organization.listOrganization(TestDataGenerator.generatePaginationParams());
-
-      expect(organizations).toBeDefined();
-      expect(organizations.organizations).toBeDefined();
-      expect(Array.isArray(organizations.organizations)).toBe(true);
-      expect(organizations.organizations.length).toBeGreaterThan(0);
-
-      // Verify basic organization attributes
-      const firstOrg = organizations.organizations[0];
-      expect(firstOrg.id).toBeDefined();
-      expect(firstOrg.displayName).toBeDefined();
-    });
-
-    it('should handle pagination', async () => {
-      const firstPage = await client.organization.listOrganization(TestDataGenerator.generatePaginationParams(5));
-
-      expect(firstPage).toBeDefined();
-      expect(firstPage.organizations.length).toBeLessThanOrEqual(5);
-
-      if (firstPage.nextPageToken) {
-        const secondPage = await client.organization.listOrganization({
-          pageSize: 5,
-          pageToken: firstPage.nextPageToken
-        });
-
-        expect(secondPage).toBeDefined();
-        expect(secondPage.organizations).toBeDefined();
-      }
-    });
-  });
-
-  describe('getOrganization', () => {
-    it('should get organization by ID', async () => {
-      const organization = await client.organization.getOrganization(testOrg);
-      
-      expect(organization).toBeDefined();
-      expect(organization.organization).toBeDefined();
-      expect(organization.organization?.id).toBe(testOrg);
-      expect(organization.organization?.displayName).toBeDefined();
-    });
-  });
-
-  describe('upsertUserManagementSettings', () => {
-    it('should upsert max allowed users', async () => {
-      const maxUsers = 50;
-      let settings;
-      try {
-        settings = await client.organization.upsertUserManagementSettings(testOrg, { maxAllowedUsers: maxUsers });
-      } catch (error) {
-        console.warn('Skipping upsertUserManagementSettings test due to error:', error);
-        return;
-      }
-
-      expect(settings).toBeDefined();
-      expect(settings?.maxAllowedUsers).toBe(maxUsers);
-    });
-  });
-}); 

package/tests/passwordless.test.ts

@@ -1,108 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { TemplateType } from '../src/pkg/grpc/scalekit/v1/auth/passwordless_pb';
-import { describe, it, expect, beforeEach } from '@jest/globals';
-import { TestDataGenerator } from './utils/test-data';
-
-describe('Passwordless', () => {
-  let client: ScalekitClient;
-
-  beforeEach(() => {
-    // Use global client
-    client = global.client;
-  });
-
-  describe('sendPasswordlessEmail', () => {
-    it('should send passwordless email with basic parameters', async () => {
-      const email = TestDataGenerator.generateUniqueEmail();
-      
-      const response = await client.passwordless.sendPasswordlessEmail(email, TestDataGenerator.generatePasswordlessEmailData());
-
-      expect(response).toBeDefined();
-      expect(response.authRequestId).toBeDefined();
-      expect(response.expiresAt).toBeDefined();
-      expect(response.expiresIn).toBe(3600);
-      expect(response.passwordlessType).toBeDefined();
-    });
-
-    it('should send passwordless email with template variables', async () => {
-      const email = TestDataGenerator.generateUniqueEmail();
-      
-      const response = await client.passwordless.sendPasswordlessEmail(email, TestDataGenerator.generatePasswordlessEmailWithTemplateData());
-
-      expect(response).toBeDefined();
-      expect(response.authRequestId).toBeDefined();
-    });
-
-    it('should throw error for invalid email', async () => {
-      await expect(
-        client.passwordless.sendPasswordlessEmail('', {
-          template: TemplateType.SIGNIN
-        })
-      ).rejects.toThrow('Email must be a valid string');
-    });
-
-    it('should throw error for invalid template type', async () => {
-      const email = TestDataGenerator.generateUniqueEmail();
-      
-      await expect(
-        client.passwordless.sendPasswordlessEmail(email, {
-          template: 'INVALID_TEMPLATE' as any
-        })
-      ).rejects.toThrow('Invalid template type');
-    });
-  });
-
-  describe('verifyPasswordlessEmail', () => {
-    it('should throw error when neither code nor linkToken is provided', async () => {
-      await expect(
-        client.passwordless.verifyPasswordlessEmail({})
-      ).rejects.toThrow('Either code or linkToken must be provided');
-    });
-
-    it('should verify with code', async () => {
-      // Mock code for testing - expected to fail
-      const credential = TestDataGenerator.generateCredentialData('code');
-      
-      try {
-        const response = await client.passwordless.verifyPasswordlessEmail(credential);
-        expect(response).toBeDefined();
-      } catch (error) {
-        // Expected failure with mock code
-        expect(error).toBeDefined();
-      }
-    });
-
-    it('should verify with linkToken', async () => {
-      // Mock linkToken for testing - expected to fail
-      const credential = TestDataGenerator.generateCredentialData('linkToken');
-      
-      try {
-        const response = await client.passwordless.verifyPasswordlessEmail(credential);
-        expect(response).toBeDefined();
-      } catch (error) {
-        // Expected failure with mock linkToken
-        expect(error).toBeDefined();
-      }
-    });
-  });
-
-  describe('resendPasswordlessEmail', () => {
-    it('should resend passwordless email', async () => {
-      // Send initial passwordless email
-      const email = TestDataGenerator.generateUniqueEmail();
-      
-      const sendResponse = await client.passwordless.sendPasswordlessEmail(email, TestDataGenerator.generatePasswordlessEmailData());
-
-      // Resend the email
-      const resendResponse = await client.passwordless.resendPasswordlessEmail(
-        sendResponse.authRequestId
-      );
-
-      expect(resendResponse).toBeDefined();
-      expect(resendResponse.authRequestId).toBeDefined();
-      expect(resendResponse.expiresAt).toBeDefined();
-      expect(resendResponse.expiresIn).toBeDefined();
-      expect(resendResponse.passwordlessType).toBeDefined();
-    });
-  });
-});