@scalekit-sdk/node 2.1.0 → 2.1.2

package/src/domain.ts

@@ -2,7 +2,8 @@ import { PromiseClient } from '@connectrpc/connect';
 import GrpcConnect from './connect';
 import CoreClient from './core';
 import { DomainService } from './pkg/grpc/scalekit/v1/domains/domains_connect';
-import { CreateDomainResponse, GetDomainResponse, ListDomainResponse } from './pkg/grpc/scalekit/v1/domains/domains_pb';
+import { CreateDomainResponse, GetDomainResponse, ListDomainResponse, DomainType } from './pkg/grpc/scalekit/v1/domains/domains_pb';
+import { Empty } from '@bufbuild/protobuf';
 
 export default class DomainClient {
   private client: PromiseClient<typeof DomainService>;
@@ -17,9 +18,23 @@ export default class DomainClient {
    * Create a domain for an organization with the given name. Optionally, you can provide an external id. 
    * @param {string} organizationId  The organization id
    * @param {string} name The domain name
+   * @param {object} options The options to create a domain
+   * @param {DomainType | string} options.domainType The type of domain (ALLOWED_EMAIL_DOMAIN or ORGANIZATION_DOMAIN)
    * @returns {Promise<CreateDomainResponse>} The created domain
   */
-  async createDomain(organizationId: string, name: string): Promise<CreateDomainResponse> {
+  async createDomain(organizationId: string, name: string, options?: { domainType?: DomainType | string }): Promise<CreateDomainResponse> {
+    let domainTypeValue: DomainType | undefined;
+    if (options?.domainType) {
+      if (typeof options.domainType === 'string') {
+        domainTypeValue = DomainType[options.domainType as keyof typeof DomainType];
+        if (domainTypeValue === undefined) {
+          throw new Error('Invalid domain type');
+        }
+      } else {
+        domainTypeValue = options.domainType;
+      }
+    }
+
     return this.coreClient.connectExec(
       this.client.createDomain,
       {
@@ -28,12 +43,32 @@ export default class DomainClient {
           value: organizationId
         },
         domain: {
-          domain: name
+          domain: name,
+          ...(domainTypeValue && { domainType: domainTypeValue })
         }
       }
     )
   }
 
+  /**
+   * Get a specific domain by ID for an organization
+   * @param organizationId The organization id
+   * @param domainId The domain id
+   * @returns {Promise<GetDomainResponse>} The domain details
+   */
+  async getDomain(organizationId: string, domainId: string): Promise<GetDomainResponse> {
+    return this.coreClient.connectExec(
+      this.client.getDomain,
+      {
+        id: domainId,
+        identities: {
+          case: 'organizationId',
+          value: organizationId
+        }
+      }
+    );
+  }
+
   /**
    * List domains for an organization 
    * @param organizationId The organization id
@@ -50,5 +85,19 @@ export default class DomainClient {
       },
     );
   }
+
+  async deleteDomain(organizationId: string, domainId: string): Promise<Empty> {
+    return this.coreClient.connectExec(
+      this.client.deleteDomain,
+      {
+        id: domainId,
+        identities: {
+          case: 'organizationId',
+          value: organizationId
+        }
+      }
+    );
+  }
+
 }
 

package/src/pkg/grpc/scalekit/v1/connections/connections_pb.ts

@@ -3314,6 +3314,11 @@ export class ListAppConnectionsRequest extends Message<ListAppConnectionsRequest
    */
   pageToken = "";
 
+  /**
+   * @generated from field: optional string provider = 3;
+   */
+  provider?: string;
+
   constructor(data?: PartialMessage<ListAppConnectionsRequest>) {
     super();
     proto3.util.initPartial(data, this);
@@ -3324,6 +3329,7 @@ export class ListAppConnectionsRequest extends Message<ListAppConnectionsRequest
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "page_size", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
     { no: 2, name: "page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "provider", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListAppConnectionsRequest {

package/src/pkg/grpc/scalekit/v1/domains/domains_pb.ts

@@ -29,6 +29,11 @@ export enum VerificationStatus {
    * @generated from enum value: FAILED = 3;
    */
   FAILED = 3,
+
+  /**
+   * @generated from enum value: AUTO_VERIFIED = 4;
+   */
+  AUTO_VERIFIED = 4,
 }
 // Retrieve enum metadata with: proto3.getEnumType(VerificationStatus)
 proto3.util.setEnumType(VerificationStatus, "scalekit.v1.domains.VerificationStatus", [
@@ -36,6 +41,7 @@ proto3.util.setEnumType(VerificationStatus, "scalekit.v1.domains.VerificationSta
   { no: 1, name: "PENDING" },
   { no: 2, name: "VERIFIED" },
   { no: 3, name: "FAILED" },
+  { no: 4, name: "AUTO_VERIFIED" },
 ]);
 
 /**
@@ -48,20 +54,20 @@ export enum DomainType {
   DOMAIN_TYPE_UNSPECIFIED = 0,
 
   /**
-   * @generated from enum value: HOME_REALM_DISCOVERY = 1;
+   * @generated from enum value: ALLOWED_EMAIL_DOMAIN = 1;
    */
-  HOME_REALM_DISCOVERY = 1,
+  ALLOWED_EMAIL_DOMAIN = 1,
 
   /**
-   * @generated from enum value: JIT_PROVISIONING_DOMAIN = 2;
+   * @generated from enum value: ORGANIZATION_DOMAIN = 2;
    */
-  JIT_PROVISIONING_DOMAIN = 2,
+  ORGANIZATION_DOMAIN = 2,
 }
 // Retrieve enum metadata with: proto3.getEnumType(DomainType)
 proto3.util.setEnumType(DomainType, "scalekit.v1.domains.DomainType", [
   { no: 0, name: "DOMAIN_TYPE_UNSPECIFIED" },
-  { no: 1, name: "HOME_REALM_DISCOVERY" },
-  { no: 2, name: "JIT_PROVISIONING_DOMAIN" },
+  { no: 1, name: "ALLOWED_EMAIL_DOMAIN" },
+  { no: 2, name: "ORGANIZATION_DOMAIN" },
 ]);
 
 /**

package/src/pkg/grpc/scalekit/v1/errdetails/errdetails_pb.ts

@@ -475,9 +475,14 @@ export class ToolErrorInfo extends Message<ToolErrorInfo> {
   executionId = "";
 
   /**
-   * @generated from field: string tool_message = 2;
+   * @generated from field: string tool_error_message = 2;
    */
-  toolMessage = "";
+  toolErrorMessage = "";
+
+  /**
+   * @generated from field: string tool_error_code = 3;
+   */
+  toolErrorCode = "";
 
   constructor(data?: PartialMessage<ToolErrorInfo>) {
     super();
@@ -488,7 +493,8 @@ export class ToolErrorInfo extends Message<ToolErrorInfo> {
   static readonly typeName = "scalekit.v1.errdetails.ToolErrorInfo";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "execution_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "tool_message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "tool_error_message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "tool_error_code", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ToolErrorInfo {

package/src/pkg/grpc/scalekit/v1/users/users_pb.ts

@@ -1055,6 +1055,11 @@ export class CreateMembership extends Message<CreateMembership> {
    */
   metadata: { [key: string]: string } = {};
 
+  /**
+   * @generated from field: optional string inviter_email = 8;
+   */
+  inviterEmail?: string;
+
   constructor(data?: PartialMessage<CreateMembership>) {
     super();
     proto3.util.initPartial(data, this);
@@ -1065,6 +1070,7 @@ export class CreateMembership extends Message<CreateMembership> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 4, name: "roles", kind: "message", T: Role, repeated: true },
     { no: 7, name: "metadata", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
+    { no: 8, name: "inviter_email", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateMembership {
@@ -1453,9 +1459,9 @@ export class Invite extends Message<Invite> {
   userId = "";
 
   /**
-   * @generated from field: string invited_by = 3;
+   * @generated from field: optional string invited_by = 3;
    */
-  invitedBy = "";
+  invitedBy?: string;
 
   /**
    * @generated from field: string status = 4;
@@ -1492,7 +1498,7 @@ export class Invite extends Message<Invite> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "organization_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "user_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "invited_by", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "invited_by", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 4, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 5, name: "created_at", kind: "message", T: Timestamp },
     { no: 6, name: "expires_at", kind: "message", T: Timestamp },
@@ -1731,10 +1737,16 @@ export class AssignUserRolesRequest extends Message<AssignUserRolesRequest> {
  */
 export class AssignRoleRequest extends Message<AssignRoleRequest> {
   /**
-   * @generated from field: string id = 1;
+   * @generated from field: string id = 1 [deprecated = true];
+   * @deprecated
    */
   id = "";
 
+  /**
+   * @generated from field: string role_name = 2;
+   */
+  roleName = "";
+
   constructor(data?: PartialMessage<AssignRoleRequest>) {
     super();
     proto3.util.initPartial(data, this);
@@ -1744,6 +1756,7 @@ export class AssignRoleRequest extends Message<AssignRoleRequest> {
   static readonly typeName = "scalekit.v1.users.AssignRoleRequest";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "role_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AssignRoleRequest {
@@ -1815,9 +1828,9 @@ export class RemoveUserRoleRequest extends Message<RemoveUserRoleRequest> {
   userId = "";
 
   /**
-   * @generated from field: string role_id = 3;
+   * @generated from field: string role_name = 3;
    */
-  roleId = "";
+  roleName = "";
 
   constructor(data?: PartialMessage<RemoveUserRoleRequest>) {
     super();
@@ -1829,7 +1842,7 @@ export class RemoveUserRoleRequest extends Message<RemoveUserRoleRequest> {
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "organization_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "user_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "role_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "role_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RemoveUserRoleRequest {

package/tests/domain.test.ts

@@ -0,0 +1,239 @@
+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);
+    });
+  });
+
+  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/utils/test-data.ts

@@ -1,5 +1,6 @@
 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
@@ -165,6 +166,28 @@ export class TestDataGenerator {
       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`;
+  }
 }
 
 /**
@@ -245,4 +268,47 @@ export class TestUserManager {
       }
     }
   }
+}
+
+/**
+ * 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
+      }
+    }
+  }
 }