@scalekit-sdk/node 2.1.7 → 2.1.9

package/src/webauthn.ts

@@ -0,0 +1,98 @@
+import { PromiseClient } from '@connectrpc/connect';
+import GrpcConnect from './connect';
+import CoreClient from './core';
+import { WebAuthnService } from './pkg/grpc/scalekit/v1/auth/webauthn_connect';
+import {
+  ListCredentialsRequest,
+  ListCredentialsResponse,
+  UpdateCredentialRequest,
+  UpdateCredentialResponse,
+  DeleteCredentialRequest,
+  DeleteCredentialResponse
+} from './pkg/grpc/scalekit/v1/auth/webauthn_pb';
+
+export default class WebAuthnClient {
+  private client: PromiseClient<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 = new ListCredentialsRequest({
+      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 = new UpdateCredentialRequest({
+      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 = new DeleteCredentialRequest({
+      credentialId
+    });
+
+    return this.coreClient.connectExec(
+      this.client.deleteCredential,
+      request
+    );
+  }
+}
+

package/tests/domain.test.ts

@@ -149,6 +149,60 @@ describe('Domains', () => {
       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', () => {