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

package/src/domain.ts

@@ -1,272 +0,0 @@
-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,
-  DomainType,
-} from "./pkg/grpc/scalekit/v1/domains/domains_pb";
-import { Empty } from "@bufbuild/protobuf";
-
-/**
- * Client for managing domains for organizations.
- *
- * Domains enable automatic organization identification during SSO flows based on user email addresses.
- * You can configure domains as ORGANIZATION_DOMAIN (for SSO routing) or ALLOWED_EMAIL_DOMAIN
- * (for restricting which email domains can automatically join an organization).
- *
- * @example
- * const scalekitClient = new ScalekitClient(envUrl, clientId, clientSecret);
- * const domainClient = scalekitClient.domain;
- *
- * @see {@link https://docs.scalekit.com/apis/#tag/domains | Domain API Documentation}
- */
-export default class DomainClient {
-  private client: PromiseClient<typeof DomainService>;
-  constructor(
-    private readonly grpcConncet: GrpcConnect,
-    private readonly coreClient: CoreClient
-  ) {
-    this.client = this.grpcConncet.createClient(DomainService);
-  }
-
-  /**
-   * Adds a new domain configuration to an organization for SSO routing or user suggestions.
-   *
-   * Domains serve two purposes based on their type:
-   * - **ORGANIZATION_DOMAIN**: Used to identify the SSO connection for the organization. When users
-   *   authenticate with email addresses from this domain, they're automatically routed to the
-   *   organization's SSO provider.
-   * - **ALLOWED_EMAIL_DOMAIN**: Enables users to join the organization with automatic suggestions
-   *   in the organization switcher during signup/login.
-   *
-   * Note: Public disposable domains (gmail.com, outlook.com, etc.) are automatically blocked for security.
-   *
-   * @param {string} organizationId - The organization ID (format: "org_...")
-   * @param {string} name - The domain name (e.g., "acme.com", "example.org")
-   * @param {object} [options] - Optional domain configuration
-   * @param {DomainType | string} [options.domainType] - Domain type: 'ALLOWED_EMAIL_DOMAIN' or 'ORGANIZATION_DOMAIN'
-   *
-   * @returns {Promise<CreateDomainResponse>} The created domain with ID and verification status
-   *
-   * @throws {Error} If domain type is invalid
-   * @throws {Error} If domain is a blocked public domain (gmail.com, etc.)
-   *
-   * @example
-   * // Add SSO routing domain
-   * const response = await scalekitClient.domain.createDomain(
-   *   'org_123456',
-   *   'acme.com',
-   *   { domainType: 'ORGANIZATION_DOMAIN' }
-   * );
-   * console.log('Domain created:', response.domain.id);
-   * console.log('Verification required:', response.domain.verificationStatus);
-   *
-   * @example
-   * // Add allowed email domain for user suggestions
-   * await scalekitClient.domain.createDomain(
-   *   'org_123456',
-   *   'acme.io',
-   *   { domainType: 'ALLOWED_EMAIL_DOMAIN' }
-   * );
-   *
-   * @example
-   * // Create domain with default type
-   * await scalekitClient.domain.createDomain('org_123456', 'company.com');
-   *
-   * @example
-   * // Configure multiple domains for an organization
-   * const domains = ['acme.com', 'acme.io', 'acme.net'];
-   * for (const domain of domains) {
-   *   await scalekitClient.domain.createDomain('org_123456', domain, {
-   *     domainType: 'ORGANIZATION_DOMAIN'
-   *   });
-   * }
-   *
-   * @see {@link https://docs.scalekit.com/apis/#tag/domains | Create Domain API}
-   * @see {@link listDomains} - List all domains for an organization
-   * @see {@link deleteDomain} - Remove a domain
-   */
-  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, {
-      identities: {
-        case: "organizationId",
-        value: organizationId,
-      },
-      domain: {
-        domain: name,
-        ...(!!domainTypeValue && { domainType: domainTypeValue }),
-      },
-    });
-  }
-
-  /**
-   * Retrieves detailed information about a specific domain configuration.
-   *
-   * Returns complete domain details including the domain name, type (ORGANIZATION_DOMAIN or
-   * ALLOWED_EMAIL_DOMAIN), verification status, and when it was created/updated. Use this to
-   * check domain configuration status or verification requirements.
-   *
-   * @param {string} organizationId - The organization ID (format: "org_...")
-   * @param {string} domainId - The domain ID (format: "domain_...")
-   *
-   * @returns {Promise<GetDomainResponse>} Complete domain configuration and status
-   *
-   * @example
-   * // Check domain verification status
-   * const response = await scalekitClient.domain.getDomain(
-   *   'org_123456',
-   *   'domain_abc123'
-   * );
-   * console.log('Domain:', response.domain.domain);
-   * console.log('Type:', response.domain.domainType);
-   * console.log('Verified:', response.domain.verificationStatus);
-   *
-   * @example
-   * // Verify domain configuration after creation
-   * const created = await scalekitClient.domain.createDomain(
-   *   'org_123456',
-   *   'acme.com',
-   *   { domainType: 'ORGANIZATION_DOMAIN' }
-   * );
-   *
-   * // Later, check if domain has been verified
-   * const domain = await scalekitClient.domain.getDomain(
-   *   'org_123456',
-   *   created.domain.id
-   * );
-   * if (domain.domain.verificationStatus === 'VERIFIED') {
-   *   console.log('Domain is ready for SSO routing');
-   * }
-   *
-   * @see {@link https://docs.scalekit.com/apis/#tag/domains | Get Domain API}
-   * @see {@link createDomain} - Add a new domain
-   * @see {@link listDomains} - List all domains for an organization
-   */
-  async getDomain(
-    organizationId: string,
-    domainId: string
-  ): Promise<GetDomainResponse> {
-    return this.coreClient.connectExec(this.client.getDomain, {
-      id: domainId,
-      identities: {
-        case: "organizationId",
-        value: organizationId,
-      },
-    });
-  }
-
-  private resolveDomainType(
-    domainType?: DomainType | string
-  ): DomainType | undefined {
-    if (domainType == null) return;
-    if (typeof domainType !== 'string') return domainType;
-    const resolved = DomainType[domainType as keyof typeof DomainType];
-    if (resolved === undefined) {
-      throw new Error(
-        `Invalid domain type: ${domainType}. Expected ALLOWED_EMAIL_DOMAIN or ORGANIZATION_DOMAIN`
-      );
-    }
-    return resolved;
-  }
-
-  /**
-   * Retrieves all domain configurations for an organization.
-   *
-   * Returns a complete list of domains configured for the organization, including both
-   * ORGANIZATION_DOMAIN (for SSO routing) and ALLOWED_EMAIL_DOMAIN (for user suggestions).
-   * Each domain includes its verification status, type, and configuration details.
-   *
-   * Use this to audit domain configuration, check which domains are verified, or display
-   * domain settings in an admin dashboard.
-   *
-   * @param {string} organizationId - The organization ID (format: "org_...")
-   *
-   * @param options Optional parameters for filtering domains
-   * @param {DomainType | string} options.domainType Filter domains by type (ALLOWED_EMAIL_DOMAIN or ORGANIZATION_DOMAIN)
-   * @returns {Promise<ListDomainResponse>} List of all domains with their configurations
-   *
-   * @example
-   * // List all domains for an organization
-   * const response = await scalekitClient.domain.listDomains('org_123456');
-   * console.log(`Found ${response.domains.length} domains`);
-   * response.domains.forEach(domain => {
-   *   console.log(`- ${domain.domain} (${domain.domainType}): ${domain.verificationStatus}`);
-   * });
-   *
-   * @example
-   * // Check which domains are verified for SSO
-   * const response = await scalekitClient.domain.listDomains('org_123456');
-   * const verifiedSSODomains = response.domains.filter(
-   *   d => d.domainType === 'ORGANIZATION_DOMAIN' && d.verificationStatus === 'VERIFIED'
-   * );
-   * console.log('Verified SSO domains:', verifiedSSODomains.map(d => d.domain));
-   * @see {@link https://docs.scalekit.com/apis/#tag/domains | List Domains API}
-   * @see {@link createDomain} - Add a new domain
-   * @see {@link getDomain} - Get details for a specific domain
-   * @see {@link deleteDomain} - Remove a domain
-   */
-  async listDomains(organizationId: string, options?: { domainType?: DomainType | string }): Promise<ListDomainResponse> {
-    const domainTypeValue = this.resolveDomainType(options?.domainType);
-
-    return this.coreClient.connectExec(
-      this.client.listDomains,
-      {
-        identities: {
-          case: 'organizationId',
-          value: organizationId
-        },
-        ...(!!domainTypeValue && { domainType: domainTypeValue })
-      },
-    );
-  }
-
-  /**
-   * Deletes a domain from an organization.
-   *
-   * Removes the domain configuration from the organization. Users with email addresses from
-   * this domain will no longer be automatically routed to this organization's SSO connection.
-   *
-   * @param {string} organizationId - The organization ID
-   * @param {string} domainId - The domain ID to delete
-   *
-   * @returns {Promise<Empty>} Empty response on successful deletion
-   *
-   * @example
-   * // Remove a domain from an organization
-   * await scalekitClient.domain.deleteDomain('org_123456', 'domain_abc123');
-   * console.log('Domain deleted successfully');
-   *
-   * @see {@link https://docs.scalekit.com/apis/#tag/domains | Delete Domain API}
-   * @see {@link createDomain} - Add a new domain
-   * @see {@link listDomains} - List all domains for an organization
-   */
-  async deleteDomain(organizationId: string, domainId: string): Promise<Empty> {
-    return this.coreClient.connectExec(this.client.deleteDomain, {
-      id: domainId,
-      identities: {
-        case: "organizationId",
-        value: organizationId,
-      },
-    });
-  }
-}

package/src/errors/base-exception.ts

@@ -1,262 +0,0 @@
-import { ConnectError, Code } from '@connectrpc/connect';
-import { AxiosResponse } from 'axios';
-import { ErrorInfo } from '../pkg/grpc/scalekit/v1/errdetails/errdetails_pb';
-
-// gRPC to HTTP status mapping
-const GRPC_TO_HTTP: Record<number, number> = {
-  [Code.InvalidArgument]: 400,
-  [Code.FailedPrecondition]: 400,
-  [Code.OutOfRange]: 400,
-  [Code.Unauthenticated]: 401,
-  [Code.PermissionDenied]: 403,
-  [Code.NotFound]: 404,
-  [Code.AlreadyExists]: 409,
-  [Code.Aborted]: 409,
-  [Code.ResourceExhausted]: 429,
-  [Code.Canceled]: 499,
-  [Code.DataLoss]: 500,
-  [Code.Unknown]: 500,
-  [Code.Internal]: 500,
-  [Code.Unimplemented]: 501,
-  [Code.Unavailable]: 503,
-  [Code.DeadlineExceeded]: 504,
-};
-
-// HTTP to gRPC status mapping
-const HTTP_TO_GRPC: Record<number, number> = {
-  200: Code.Unknown, // No direct mapping for 200
-  400: Code.InvalidArgument,
-  401: Code.Unauthenticated,
-  403: Code.PermissionDenied,
-  404: Code.NotFound,
-  409: Code.AlreadyExists,
-  429: Code.ResourceExhausted,
-  500: Code.Internal,
-  501: Code.Unimplemented,
-  503: Code.Unavailable,
-  504: Code.DeadlineExceeded,
-};
-
-// HTTP status constants
-const HTTP_STATUS = {
-  'OK': 200,
-  'BAD_REQUEST': 400,
-  'UNAUTHORIZED': 401,
-  'FORBIDDEN': 403,
-  'NOT_FOUND': 404,
-  'CONFLICT': 409,
-  'TOO_MANY_REQUESTS': 429,
-  'INTERNAL_SERVER_ERROR': 500,
-  'NOT_IMPLEMENTED': 501,
-  'SERVICE_UNAVAILABLE': 503,
-  'GATEWAY_TIMEOUT': 504,
-};
-
-// Base exception class
-export class ScalekitException extends Error {
-  constructor(error: any) {
-    super(error?.message || error?.toString() || 'Unknown error');
-    this.name = 'ScalekitException';
-  }
-}
-
-// Webhook verification error
-export class WebhookVerificationError extends ScalekitException {
-  constructor(error: any) {
-    super(error);
-    this.name = 'WebhookVerificationError';
-  }
-}
-
-// Token validation failure exception
-export class ScalekitValidateTokenFailureException extends ScalekitException {
-  constructor(error: any) {
-    super(error);
-    this.name = 'ScalekitValidateTokenFailureException';
-  }
-}
-
-// Base server exception
-export class ScalekitServerException extends ScalekitException {
-  private _grpcStatus: Code;
-  private _httpStatus: number;
-  private _message: string | null;
-  private _errDetails: any;
-  private _errorCode: string | null;
-  private _unpackedDetails: ErrorInfo[];
-
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    
-    this._unpackedDetails = [];
-    
-    if (this.isAxiosResponse(error)) {
-      // Handle HTTP Response errors
-      if (error.statusText && typeof error.statusText === 'string') {
-        this._httpStatus = HTTP_STATUS[error.statusText.toUpperCase() as keyof typeof HTTP_STATUS] || HTTP_STATUS.INTERNAL_SERVER_ERROR;
-      } else {
-        this._httpStatus = HTTP_STATUS.INTERNAL_SERVER_ERROR;
-      }
-      this._grpcStatus = HTTP_TO_GRPC[error.status] || Code.Unknown;
-      this._errorCode = error.statusText;
-      this._errDetails = error.data;
-      this._message = null;
-    } else {
-      // Handle gRPC ConnectError
-      this._grpcStatus = error.code;
-      this._httpStatus = GRPC_TO_HTTP[error.code] || 500;
-      this._message = error.message;
-      this._errDetails = error.findDetails(ErrorInfo);
-      this._errorCode = null;
-
-      // Unpack error details
-      for (const detail of this._errDetails) {
-        this._unpackedDetails.push(detail);
-        if (!this._errorCode) {
-          this._errorCode = detail.errorCode;
-        }
-      }
-    }
-
-    this.name = 'ScalekitServerException';
-  }
-
-  private isAxiosResponse(error: any): error is AxiosResponse {
-    return error && typeof error.status === 'number' && typeof error.statusText === 'string';
-  }
-
-  // String representation
-  toString(): string {
-    const border = '='.repeat(40);
-    
-    if (this._unpackedDetails.length > 0) {
-      let detailsStr = JSON.stringify(this._unpackedDetails, null, 2);
-      
-      // Format the JSON string for better readability
-      
-      if (detailsStr.startsWith("[") && detailsStr.includes("\n")) {
-        detailsStr = "[\n" + detailsStr.substring(1);
-      }
-      
-      return `\n${border}\n` +
-             `Error Code: ${this._errorCode}\n` +
-             `GRPC: (${this.getGrpcStatusName()}: ${this._grpcStatus})\n` +
-             `HTTP: (${this.getHttpStatusName()}: ${this._httpStatus})\n` +
-             `Error Details:\n` +
-             `${this._message}: ${detailsStr}\n${border}\n`;
-    } else {
-      return `\n${border}\n` +
-             `Error Code: ${this._errorCode}\n` +
-             `GRPC: (${this.getGrpcStatusName()}: ${this._grpcStatus})\n` +
-             `HTTP: (${this.getHttpStatusName()}: ${this._httpStatus})\n` +
-             `Error Details: ${this._errDetails}\n${border}\n`;
-    }
-  }
-
-  // Helper method to get gRPC status name
-  private getGrpcStatusName(): string {
-    switch (this._grpcStatus) {
-      case Code.InvalidArgument: return 'INVALID_ARGUMENT';
-      case Code.FailedPrecondition: return 'FAILED_PRECONDITION';
-      case Code.OutOfRange: return 'OUT_OF_RANGE';
-      case Code.Unauthenticated: return 'UNAUTHENTICATED';
-      case Code.PermissionDenied: return 'PERMISSION_DENIED';
-      case Code.NotFound: return 'NOT_FOUND';
-      case Code.AlreadyExists: return 'ALREADY_EXISTS';
-      case Code.Aborted: return 'ABORTED';
-      case Code.ResourceExhausted: return 'RESOURCE_EXHAUSTED';
-      case Code.Canceled: return 'CANCELED';
-      case Code.DataLoss: return 'DATA_LOSS';
-      case Code.Unknown: return 'UNKNOWN';
-      case Code.Internal: return 'INTERNAL';
-      case Code.Unimplemented: return 'UNIMPLEMENTED';
-      case Code.Unavailable: return 'UNAVAILABLE';
-      case Code.DeadlineExceeded: return 'DEADLINE_EXCEEDED';
-      default: return 'UNKNOWN';
-    }
-  }
-
-  // Helper method to get HTTP status name
-  private getHttpStatusName(): string {
-    switch (this._httpStatus) {
-      case 200: return 'OK';
-      case 400: return 'BAD_REQUEST';
-      case 401: return 'UNAUTHORIZED';
-      case 403: return 'FORBIDDEN';
-      case 404: return 'NOT_FOUND';
-      case 409: return 'CONFLICT';
-      case 429: return 'TOO_MANY_REQUESTS';
-      case 500: return 'INTERNAL_SERVER_ERROR';
-      case 501: return 'NOT_IMPLEMENTED';
-      case 503: return 'SERVICE_UNAVAILABLE';
-      case 504: return 'GATEWAY_TIMEOUT';
-      default: return 'INTERNAL_SERVER_ERROR';
-    }
-  }
-
-  // Getters
-  get grpcStatus(): Code {
-    return this._grpcStatus;
-  }
-
-  get httpStatus(): number {
-    return this._httpStatus;
-  }
-
-  get errorCode(): string | null {
-    return this._errorCode;
-  }
-
-  get message(): string {
-    return this._message || super.message;
-  }
-
-  get errDetails(): any {
-    return this._errDetails;
-  }
-
-  get unpackedDetails(): ErrorInfo[] {
-    return this._unpackedDetails;
-  }
-
-  static promote(error: AxiosResponse | ConnectError): ScalekitServerException {
-    // Use dynamic import to avoid circular dependency
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const specific = require('./specific-exceptions');
-    const grpcStatus = error instanceof ConnectError
-      ? error.code
-      : HTTP_TO_GRPC[error.status] || Code.Unknown;
-
-    switch (grpcStatus) {
-      case Code.InvalidArgument:
-      case Code.FailedPrecondition:
-      case Code.OutOfRange:
-        return new specific.ScalekitBadRequestException(error);
-      case Code.Unauthenticated:
-        return new specific.ScalekitUnauthorizedException(error);
-      case Code.PermissionDenied:
-        return new specific.ScalekitForbiddenException(error);
-      case Code.NotFound:
-        return new specific.ScalekitNotFoundException(error);
-      case Code.AlreadyExists:
-      case Code.Aborted:
-        return new specific.ScalekitConflictException(error);
-      case Code.ResourceExhausted:
-        return new specific.ScalekitTooManyRequestsException(error);
-      case Code.Canceled:
-        return new specific.ScalekitCancelledException(error);
-      case Code.DataLoss:
-      case Code.Unknown:
-      case Code.Internal:
-        return new specific.ScalekitInternalServerException(error);
-      case Code.Unimplemented:
-        return new specific.ScalekitNotImplementedException(error);
-      case Code.Unavailable:
-        return new specific.ScalekitServiceUnavailableException(error);
-      case Code.DeadlineExceeded:
-        return new specific.ScalekitGatewayTimeoutException(error);
-      default:
-        return new specific.ScalekitUnknownException(error);
-    }
-  }
-} 

package/src/errors/index.ts

@@ -1,3 +0,0 @@
-// Export base exceptions
-export * from './base-exception';
-export * from './specific-exceptions'; 

package/src/errors/specific-exceptions.ts

@@ -1,88 +0,0 @@
-import { ConnectError } from '@connectrpc/connect';
-import { AxiosResponse } from 'axios';
-import { ScalekitServerException } from './base-exception';
-
-// Specific exception classes 
-export class ScalekitBadRequestException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitBadRequestException';
-  }
-}
-
-export class ScalekitUnauthorizedException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitUnauthorizedException';
-  }
-}
-
-export class ScalekitForbiddenException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitForbiddenException';
-  }
-}
-
-export class ScalekitNotFoundException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitNotFoundException';
-  }
-}
-
-export class ScalekitConflictException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitConflictException';
-  }
-}
-
-export class ScalekitTooManyRequestsException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitTooManyRequestsException';
-  }
-}
-
-export class ScalekitInternalServerException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitInternalServerException';
-  }
-}
-
-export class ScalekitNotImplementedException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitNotImplementedException';
-  }
-}
-
-export class ScalekitServiceUnavailableException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitServiceUnavailableException';
-  }
-}
-
-export class ScalekitGatewayTimeoutException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitGatewayTimeoutException';
-  }
-}
-
-export class ScalekitCancelledException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitCancelledException';
-  }
-}
-
-export class ScalekitUnknownException extends ScalekitServerException {
-  constructor(error: AxiosResponse | ConnectError) {
-    super(error);
-    this.name = 'ScalekitUnknownException';
-  }
-} 

package/src/index.ts

@@ -1,10 +0,0 @@
-import ScalekitClient from "./scalekit";
-
-export { ScalekitClient };
-export { ScalekitClient as Scalekit };
-export default ScalekitClient;
-
-export * from "./types/scalekit";
-export * from "./types/auth";
-
-export * from "./errors";