@scalekit-sdk/node 2.1.2 → 2.1.4

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

@@ -1459,9 +1459,9 @@ export class Invite extends Message<Invite> {
   userId = "";
 
   /**
-   * @generated from field: optional string invited_by = 3;
+   * @generated from field: optional string inviter_email = 3;
    */
-  invitedBy?: string;
+  inviterEmail?: string;
 
   /**
    * @generated from field: string status = 4;
@@ -1498,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 */, opt: true },
+    { no: 3, name: "inviter_email", 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 },

package/src/role.ts

@@ -0,0 +1,261 @@
+import { Empty, PartialMessage } from '@bufbuild/protobuf';
+import { PromiseClient } from '@connectrpc/connect';
+import GrpcConnect from './connect';
+import CoreClient from './core';
+import { RolesService } from './pkg/grpc/scalekit/v1/roles/roles_connect';
+import { 
+  CreateRoleRequest,
+  CreateRoleResponse,
+  UpdateRoleRequest,
+  UpdateRoleResponse,
+  GetRoleRequest,
+  GetRoleResponse,
+  ListRolesRequest,
+  ListRolesResponse,
+  DeleteRoleRequest,
+  CreateOrganizationRoleRequest,
+  CreateOrganizationRoleResponse,
+  UpdateOrganizationRoleRequest,
+  UpdateOrganizationRoleResponse,
+  GetOrganizationRoleRequest,
+  GetOrganizationRoleResponse,
+  ListOrganizationRolesRequest,
+  ListOrganizationRolesResponse,
+  DeleteOrganizationRoleRequest,
+  GetRoleUsersCountRequest,
+  GetRoleUsersCountResponse,
+  GetOrganizationRoleUsersCountRequest,
+  GetOrganizationRoleUsersCountResponse,
+  UpdateDefaultOrganizationRolesRequest,
+  UpdateDefaultOrganizationRolesResponse,
+  DeleteOrganizationRoleBaseRequest,
+  CreateRole,
+  UpdateRole,
+  CreateOrganizationRole
+} from './pkg/grpc/scalekit/v1/roles/roles_pb';
+
+export default class RoleClient {
+  private client: PromiseClient<typeof RolesService>;
+
+  constructor(
+    private readonly grpcConnect: GrpcConnect,
+    private readonly coreClient: CoreClient
+  ) {
+    this.client = this.grpcConnect.createClient(RolesService);
+  }
+
+  /**
+   * Create a new role
+   * @param {CreateRole} role The role creation object
+   * @returns {Promise<CreateRoleResponse>} The created role
+   */
+  async createRole(role: CreateRole): Promise<CreateRoleResponse> {
+    return this.coreClient.connectExec(
+      this.client.createRole,
+      { role }
+    );
+  }
+
+  /**
+   * Get role by name
+   * @param {string} roleName The role name
+   * @returns {Promise<GetRoleResponse>} The role details
+   */
+  async getRole(roleName: string): Promise<GetRoleResponse> {
+    return this.coreClient.connectExec(
+      this.client.getRole,
+      { roleName }
+    );
+  }
+
+  /**
+   * List all roles
+   * @returns {Promise<ListRolesResponse>} List of roles
+   */
+  async listRoles(): Promise<ListRolesResponse> {
+    return this.coreClient.connectExec(
+      this.client.listRoles,
+      {}
+    );
+  }
+
+  /**
+   * Update an existing role by name
+   * @param {string} roleName The role name to update
+   * @param {UpdateRole} role The role update object
+   * @returns {Promise<UpdateRoleResponse>} The updated role
+   */
+  async updateRole(roleName: string, role: UpdateRole): Promise<UpdateRoleResponse> {
+    return this.coreClient.connectExec(
+      this.client.updateRole,
+      { 
+        roleName,
+        role 
+      }
+    );
+  }
+
+  /**
+   * Delete role by name
+   * @param {string} roleName The role name to be deleted
+   * @param {string} [reassignRoleName] The role name to reassign users to when deleting this role
+   * @returns {Promise<Empty>} Empty response
+   */
+  async deleteRole(roleName: string, reassignRoleName?: string): Promise<Empty> {
+    const request: PartialMessage<DeleteRoleRequest> = { roleName };
+    if (reassignRoleName) {
+      request.reassignRoleName = reassignRoleName;
+    }
+    
+    return this.coreClient.connectExec(
+      this.client.deleteRole,
+      request
+    );
+  }
+
+  /**
+   * Get the count of users associated with a role
+   * @param {string} roleName The role name to get user count for
+   * @returns {Promise<GetRoleUsersCountResponse>} The user count response
+   */
+  async getRoleUsersCount(roleName: string): Promise<GetRoleUsersCountResponse> {
+    return this.coreClient.connectExec(
+      this.client.getRoleUsersCount,
+      { roleName }
+    );
+  }
+
+  // Organization Role CRUD Methods
+
+  /**
+   * Create a new organization role
+   * @param {string} orgId The organization ID
+   * @param {CreateOrganizationRole} role The organization role creation object
+   * @returns {Promise<CreateOrganizationRoleResponse>} The created organization role
+   */
+  async createOrganizationRole(orgId: string, role: CreateOrganizationRole): Promise<CreateOrganizationRoleResponse> {
+    return this.coreClient.connectExec(
+      this.client.createOrganizationRole,
+      {
+        orgId,
+        role
+      }
+    );
+  }
+
+  /**
+   * Get organization role by name
+   * @param {string} orgId The organization ID
+   * @param {string} roleName The role name
+   * @returns {Promise<GetOrganizationRoleResponse>} The organization role details
+   */
+  async getOrganizationRole(orgId: string, roleName: string): Promise<GetOrganizationRoleResponse> {
+    return this.coreClient.connectExec(
+      this.client.getOrganizationRole,
+      {
+        orgId,
+        roleName
+      }
+    );
+  }
+
+  /**
+   * List all organization roles
+   * @param {string} orgId The organization ID
+   * @returns {Promise<ListOrganizationRolesResponse>} List of organization roles
+   */
+  async listOrganizationRoles(orgId: string): Promise<ListOrganizationRolesResponse> {
+    return this.coreClient.connectExec(
+      this.client.listOrganizationRoles,
+      { orgId }
+    );
+  }
+
+  /**
+   * Update an existing organization role by name
+   * @param {string} orgId The organization ID
+   * @param {string} roleName The role name to update
+   * @param {UpdateRole} role The organization role update object
+   * @returns {Promise<UpdateOrganizationRoleResponse>} The updated organization role
+   */
+  async updateOrganizationRole(orgId: string, roleName: string, role: UpdateRole): Promise<UpdateOrganizationRoleResponse> {
+    return this.coreClient.connectExec(
+      this.client.updateOrganizationRole,
+      {
+        orgId,
+        roleName,
+        role
+      }
+    );
+  }
+
+  /**
+   * Delete organization role by name
+   * @param {string} orgId The organization ID
+   * @param {string} roleName The role name to be deleted
+   * @param {string} [reassignRoleName] The role name to reassign users to when deleting this role
+   * @returns {Promise<Empty>} Empty response
+   */
+  async deleteOrganizationRole(orgId: string, roleName: string, reassignRoleName?: string): Promise<Empty> {
+    const request: PartialMessage<DeleteOrganizationRoleRequest> = {
+      orgId,
+      roleName
+    };
+    if (reassignRoleName) {
+      request.reassignRoleName = reassignRoleName;
+    }
+    
+    return this.coreClient.connectExec(
+      this.client.deleteOrganizationRole,
+      request
+    );
+  }
+
+  /**
+   * Get the count of users associated with an organization role
+   * @param {string} orgId The organization ID
+   * @param {string} roleName The role name to get user count for
+   * @returns {Promise<GetOrganizationRoleUsersCountResponse>} The user count response
+   */
+  async getOrganizationRoleUsersCount(orgId: string, roleName: string): Promise<GetOrganizationRoleUsersCountResponse> {
+    return this.coreClient.connectExec(
+      this.client.getOrganizationRoleUsersCount,
+      {
+        orgId,
+        roleName
+      }
+    );
+  }
+
+  /**
+   * Update default organization roles
+   * @param {string} orgId The organization ID
+   * @param {string} defaultMemberRole The default member role name
+   * @returns {Promise<UpdateDefaultOrganizationRolesResponse>} The updated default roles response
+   */
+  async updateDefaultOrganizationRoles(orgId: string, defaultMemberRole: string): Promise<UpdateDefaultOrganizationRolesResponse> {
+    return this.coreClient.connectExec(
+      this.client.updateDefaultOrganizationRoles,
+      {
+        orgId,
+        defaultMemberRole
+      }
+    );
+  }
+
+  /**
+   * Delete organization role base relationship
+   * @param {string} orgId The organization ID
+   * @param {string} roleName The role name to remove base relationship for
+   * @returns {Promise<Empty>} Empty response
+   */
+  async deleteOrganizationRoleBase(orgId: string, roleName: string): Promise<Empty> {
+    return this.coreClient.connectExec(
+      this.client.deleteOrganizationRoleBase,
+      {
+        orgId,
+        roleName
+      }
+    );
+  }
+}

package/src/scalekit.ts

@@ -10,6 +10,9 @@ import DomainClient from './domain';
 import OrganizationClient from './organization';
 import PasswordlessClient from './passwordless';
 import UserClient from './user';
+import SessionClient from './session';
+import RoleClient from './role';
+import PermissionClient from './permission';
 import { IdpInitiatedLoginClaims, IdTokenClaim, User } from './types/auth';
 import { AuthenticationOptions, AuthenticationResponse, AuthorizationUrlOptions, GrantType, LogoutUrlOptions, RefreshTokenResponse ,TokenValidationOptions } from './types/scalekit';
 import { WebhookVerificationError, ScalekitValidateTokenFailureException } from './errors/base-exception';
@@ -37,6 +40,9 @@ export default class ScalekitClient {
   readonly directory: DirectoryClient;
   readonly passwordless: PasswordlessClient;
   readonly user: UserClient;
+  readonly session: SessionClient;
+  readonly role: RoleClient;
+  readonly permission: PermissionClient;
   constructor(
     envUrl: string,
     clientId: string,
@@ -75,6 +81,18 @@ export default class ScalekitClient {
       this.grpcConnect,
       this.coreClient
     );
+    this.session = new SessionClient(
+      this.grpcConnect,
+      this.coreClient
+    );
+    this.role = new RoleClient(
+      this.grpcConnect,
+      this.coreClient
+    );
+    this.permission = new PermissionClient(
+      this.grpcConnect,
+      this.coreClient
+    );
   }
 
   /**

package/src/session.ts

@@ -0,0 +1,134 @@
+import { PartialMessage } from '@bufbuild/protobuf';
+import { PromiseClient } from '@connectrpc/connect';
+import GrpcConnect from './connect';
+import CoreClient from './core';
+import { SessionService } from './pkg/grpc/scalekit/v1/sessions/sessions_connect';
+import { 
+  SessionDetailsRequest,
+  SessionDetails,
+  UserSessionDetailsRequest,
+  UserSessionDetails,
+  UserSessionFilter,
+  RevokeSessionRequest,
+  RevokeSessionResponse,
+  RevokeAllUserSessionsRequest,
+  RevokeAllUserSessionsResponse
+} from './pkg/grpc/scalekit/v1/sessions/sessions_pb';
+import { Timestamp } from '@bufbuild/protobuf';
+
+export default class SessionClient {
+  private client: PromiseClient<typeof SessionService>;
+
+  constructor(
+    private readonly grpcConnect: GrpcConnect,
+    private readonly coreClient: CoreClient
+  ) {
+    this.client = this.grpcConnect.createClient(SessionService);
+  }
+
+  /**
+   * Get details for a specific session
+   * @param {string} sessionId The session id
+   * @returns {Promise<SessionDetails>} The session details
+   */
+  async getSession(sessionId: string): Promise<SessionDetails> {
+    return this.coreClient.connectExec(
+      this.client.getSession,
+      {
+        sessionId
+      }
+    );
+  }
+
+  /**
+   * Get all session details for a user with pagination and filtering
+   * @param {string} userId The user id
+   * @param {object} options The pagination and filtering options
+   * @param {number} options.pageSize The page size
+   * @param {string} options.pageToken The page token
+   * @param {object} options.filter The session filter options
+   * @param {string[]} options.filter.status The session statuses to filter by
+   * @param {Date} options.filter.startTime The start time for filtering sessions
+   * @param {Date} options.filter.endTime The end time for filtering sessions
+   * @returns {Promise<UserSessionDetails>} The user session details
+   */
+  async getUserSessions(
+    userId: string,
+    options?: {
+      pageSize?: number,
+      pageToken?: string,
+      filter?: {
+        status?: string[],
+        startTime?: Date,
+        endTime?: Date
+      }
+    }
+  ): Promise<UserSessionDetails> {
+    const request: PartialMessage<UserSessionDetailsRequest> = {
+      userId
+    };
+
+    if (options?.pageSize !== undefined) {
+      request.pageSize = options.pageSize;
+    }
+
+    if (options?.pageToken) {
+      request.pageToken = options.pageToken;
+    }
+
+    if (options?.filter) {
+      const filter = new UserSessionFilter();
+      
+      if (options.filter.status) {
+        filter.status = options.filter.status;
+      }
+      
+      if (options.filter.startTime) {
+        filter.startTime = Timestamp.fromDate(options.filter.startTime);
+      }
+      
+      if (options.filter.endTime) {
+        filter.endTime = Timestamp.fromDate(options.filter.endTime);
+      }
+      
+      request.filter = filter;
+    }
+
+    return this.coreClient.connectExec(
+      this.client.getUserSessions,
+      request
+    );
+  }
+
+  /**
+   * Revoke a session for a user
+   * @param {string} sessionId The session id to revoke
+   * @returns {Promise<RevokeSessionResponse>} The response with revoked session details
+   */
+  async revokeSession(sessionId: string): Promise<RevokeSessionResponse> {
+    return this.coreClient.connectExec(
+      this.client.revokeSession,
+      {
+        sessionId
+      }
+    );
+  }
+
+  /**
+   * Revoke all sessions for a user
+   * @param {string} userId The user id whose sessions should be revoked
+   * @returns {Promise<RevokeAllUserSessionsResponse>} The response with all revoked session details
+   */
+  async revokeAllUserSessions(userId: string): Promise<RevokeAllUserSessionsResponse> {
+    if (!userId) {
+      throw new Error('userId is required');
+    }
+
+    return this.coreClient.connectExec(
+      this.client.revokeAllUserSessions,
+      {
+        userId
+      }
+    );
+  }
+}