@scalekit-sdk/node 2.2.0 → 2.2.2

package/src/webauthn.ts

@@ -1,99 +0,0 @@
-import { create } from '@bufbuild/protobuf';
-import type { Client } from '@connectrpc/connect';
-import GrpcConnect from './connect';
-import CoreClient from './core';
-import { WebAuthnService } from './pkg/grpc/scalekit/v1/auth/webauthn_pb';
-import {
-  ListCredentialsRequestSchema,
-  UpdateCredentialRequestSchema,
-  DeleteCredentialRequestSchema,
-  ListCredentialsResponse,
-  UpdateCredentialResponse,
-  DeleteCredentialResponse
-} from './pkg/grpc/scalekit/v1/auth/webauthn_pb';
-
-export default class WebAuthnClient {
-  private client: Client<typeof WebAuthnService>;
-
-  constructor(
-    private readonly grpcConnect: GrpcConnect,
-    private readonly coreClient: CoreClient
-  ) {
-    this.client = this.grpcConnect.createClient(WebAuthnService);
-  }
-
-  /**
-   * List all WebAuthn credentials for a user
-   * @param {string} userId The user ID to list credentials for
-   * @returns {Promise<ListCredentialsResponse>} The response containing:
-   * - credentials: Array of WebAuthn credentials
-   * - allAcceptedCredentialsOptions: Options for all accepted credentials
-   */
-  async listCredentials(userId: string): Promise<ListCredentialsResponse> {
-    if (!userId || typeof userId !== 'string') {
-      throw new Error('userId must be a non-empty string');
-    }
-
-    const request = create(ListCredentialsRequestSchema, {
-      userId
-    });
-
-    return this.coreClient.connectExec(
-      this.client.listCredentials,
-      request
-    );
-  }
-
-  /**
-   * Update a WebAuthn credential's display name
-   * @param {string} credentialId The credential ID to update
-   * @param {string} displayName The new display name for the credential
-   * @returns {Promise<UpdateCredentialResponse>} The response containing:
-   * - credential: The updated WebAuthn credential
-   */
-  async updateCredential(
-    credentialId: string,
-    displayName: string
-  ): Promise<UpdateCredentialResponse> {
-    if (!credentialId || typeof credentialId !== 'string') {
-      throw new Error('credentialId must be a non-empty string');
-    }
-
-    if (!displayName || typeof displayName !== 'string') {
-      throw new Error('displayName must be a non-empty string');
-    }
-
-    const request = create(UpdateCredentialRequestSchema, {
-      credentialId,
-      displayName
-    });
-
-    return this.coreClient.connectExec(
-      this.client.updateCredential,
-      request
-    );
-  }
-
-  /**
-   * Delete a WebAuthn credential
-   * @param {string} credentialId The credential ID to delete
-   * @returns {Promise<DeleteCredentialResponse>} The response containing:
-   * - success: Boolean indicating if the deletion was successful
-   * - unknownCredentialOptions: Options if the credential was not found
-   */
-  async deleteCredential(credentialId: string): Promise<DeleteCredentialResponse> {
-    if (!credentialId || typeof credentialId !== 'string') {
-      throw new Error('credentialId must be a non-empty string');
-    }
-
-    const request = create(DeleteCredentialRequestSchema, {
-      credentialId
-    });
-
-    return this.coreClient.connectExec(
-      this.client.deleteCredential,
-      request
-    );
-  }
-}
-

package/tests/README.md

@@ -1,25 +0,0 @@
-# Scalekit Node SDK Tests
-
-This directory contains the test suite for the Scalekit Node SDK.
-
-## Setup
-
-1. Create a `.env` file in the root directory with the following environment variables:
-
-```env
-# Required for client initialization
-SCALEKIT_ENVIRONMENT_URL= "Your Scalekit environment URL."
-SCALEKIT_CLIENT_ID= " Your Scalekit environment client id "
-SCALEKIT_CLIENT_SECRET= " Your Scalekit environment client secret "
-```
-
-2. Install dependencies:
-```bash
-npm install
-```
-
-## Running Tests
-
-- Run all tests: `npm test`
-- Run tests in watch mode: `npm run test:watch`
-

package/tests/connection.test.ts

@@ -1,42 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { TestOrganizationManager } from './utils/test-data';
-
-describe('Connections', () => {
-  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('listConnections', () => {
-    it('should list connections by organization', async () => {
-      const connections = await client.connection.listConnections(testOrg);
-
-      expect(connections).toBeDefined();
-      expect(connections.connections).toBeDefined();
-      expect(Array.isArray(connections.connections)).toBe(true);
-    });
-  });
-
-  describe('listConnectionsByDomain', () => {
-    it('should list connections by domain', async () => {
-      const domain = 'example.com';
-      const connections = await client.connection.listConnectionsByDomain(domain);
-
-      expect(connections).toBeDefined();
-      expect(connections.connections).toBeDefined();
-      expect(Array.isArray(connections.connections)).toBe(true);
-    });
-  });
-}); 

package/tests/directory.test.ts

@@ -1,46 +0,0 @@
-import ScalekitClient from '../src/scalekit';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { TestOrganizationManager } from './utils/test-data';
-
-describe('Directories', () => {
-  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('listDirectories', () => {
-    it('should list directories', async () => {
-      const directories = await client.directory.listDirectories(testOrg);
-
-      expect(directories).toBeDefined();
-      expect(directories.directories).toBeDefined();
-      expect(Array.isArray(directories.directories)).toBe(true);
-    });
-  });
-
-  describe('getPrimaryDirectoryByOrganizationId', () => {
-    it('should get primary directory by organization id', async () => {
-      try {
-        const primaryDirectory = await client.directory.getPrimaryDirectoryByOrganizationId(testOrg);
-        
-        expect(primaryDirectory).toBeDefined();
-        expect(primaryDirectory.id).toBeDefined();
-        expect(primaryDirectory.organizationId).toBe(testOrg);
-      } catch (error) {
-        // Expected when no directories exist
-        expect(error).toBeDefined();
-      }
-    });
-  });
-}); 

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