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

package/src/connect.ts

@@ -1,33 +0,0 @@
-import { ServiceType } from '@bufbuild/protobuf';
-import { PromiseClient, Transport, createPromiseClient } from '@connectrpc/connect';
-import { createGrpcTransport } from '@connectrpc/connect-node';
-import CoreClient, { headers } from './core';
-
-export default class GrpcConnect {
-  private transport: Transport;
-  constructor(
-    private readonly coreClient: CoreClient
-  ) {
-    this.transport = createGrpcTransport({
-      baseUrl: this.coreClient.envUrl,
-      httpVersion: "2",
-      interceptors: [
-        (next) => {
-          return (req) => {
-            req.header.set(headers['user-agent'], this.coreClient.userAgent)
-            req.header.set(headers['x-sdk-version'], this.coreClient.sdkVersion)
-            req.header.set(headers['x-api-version'], this.coreClient.apiVersion)
-            if (this.coreClient.accessToken) {
-              req.header.set(headers.authorization, `Bearer ${this.coreClient.accessToken}`)
-            }
-            return next(req)
-          }
-        }
-      ],
-    });
-  }
-
-  createClient<T extends ServiceType>(service: T): PromiseClient<T> {
-    return createPromiseClient(service, this.transport);
-  }
-}

package/src/connected-accounts.ts

@@ -1,358 +0,0 @@
-import { PartialMessage } from "@bufbuild/protobuf";
-import { PromiseClient } from "@connectrpc/connect";
-import GrpcConnect from "./connect";
-import CoreClient from "./core";
-import { ScalekitNotFoundException } from "./errors";
-import { ConnectedAccountService } from "./pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_connect";
-import {
-  AuthorizationDetails,
-  CreateConnectedAccount,
-  CreateConnectedAccountRequest,
-  CreateConnectedAccountResponse,
-  DeleteConnectedAccountRequest,
-  DeleteConnectedAccountResponse,
-  GetConnectedAccountByIdentifierRequest,
-  GetConnectedAccountByIdentifierResponse,
-  GetMagicLinkForConnectedAccountRequest,
-  GetMagicLinkForConnectedAccountResponse,
-  ListConnectedAccountsRequest,
-  ListConnectedAccountsResponse,
-  OauthToken,
-  UpdateConnectedAccount,
-  UpdateConnectedAccountRequest,
-  UpdateConnectedAccountResponse,
-} from "./pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_pb";
-
-/**
- * Client for managing connected accounts for third-party integrations.
- *
- * This mirrors the Python SDK `ConnectedAccountsClient` and exposes a typed,
- * ergonomic API around the `ConnectedAccountService` to:
- * - list connected accounts
- * - create/update/delete connected accounts
- * - generate magic links for authorization
- * - fetch full authentication details for a connected account
- */
-export default class ConnectedAccountsClient {
-  private client: PromiseClient<typeof ConnectedAccountService>;
-
-  constructor(
-    private readonly grpcConnect: GrpcConnect,
-    private readonly coreClient: CoreClient
-  ) {
-    this.client = this.grpcConnect.createClient(ConnectedAccountService);
-  }
-
-  /**
-   * Lists connected accounts with optional filters and pagination.
-   *
-   * @param options Optional filtering and pagination parameters
-   */
-  async listConnectedAccounts(options?: {
-    organizationId?: string;
-    userId?: string;
-    connector?: string;
-    identifier?: string;
-    provider?: string;
-    pageSize?: number;
-    pageToken?: string;
-    query?: string;
-  }): Promise<ListConnectedAccountsResponse> {
-    const request: PartialMessage<ListConnectedAccountsRequest> = {};
-
-    if (options?.organizationId) {
-      request.organizationId = options.organizationId;
-    }
-    if (options?.userId) {
-      request.userId = options.userId;
-    }
-    if (options?.connector) {
-      request.connector = options.connector;
-    }
-    if (options?.identifier) {
-      request.identifier = options.identifier;
-    }
-    if (options?.provider) {
-      request.provider = options.provider;
-    }
-    if (options?.pageSize !== undefined) {
-      request.pageSize = options.pageSize;
-    }
-    if (options?.pageToken) {
-      request.pageToken = options.pageToken;
-    }
-    if (options?.query) {
-      request.query = options.query;
-    }
-
-    return this.coreClient.connectExec(
-      this.client.listConnectedAccounts,
-      request
-    );
-  }
-
-  /**
-   * Creates a new connected account.
-   *
-   * @param params Connected account creation parameters
-   */
-  async createConnectedAccount(params: {
-    connector: string;
-    identifier: string;
-    connectedAccount: CreateConnectedAccount;
-    organizationId?: string;
-    userId?: string;
-  }): Promise<CreateConnectedAccountResponse> {
-    const {
-      connector,
-      identifier,
-      connectedAccount,
-      organizationId,
-      userId,
-    } = params;
-
-    const request: PartialMessage<CreateConnectedAccountRequest> = {
-      connector,
-      identifier,
-      connectedAccount,
-    };
-
-    if (organizationId) {
-      request.organizationId = organizationId;
-    }
-    if (userId) {
-      request.userId = userId;
-    }
-
-    return this.coreClient.connectExec(
-      this.client.createConnectedAccount,
-      request
-    );
-  }
-
-  /**
-   * Gets an existing connected account by connector and identifier, or creates one if none exists.
-   * Mirrors the Python SDK `get_or_create_connected_account`. When creating, the backend may require
-   * valid authorization details; if omitted, a minimal payload is sent and the server may return
-   * a validation error.
-   *
-   * @param params Get-or-create parameters
-   * @param params.connector Connector identifier (required)
-   * @param params.identifier Connected account identifier (required)
-   * @param params.authorizationDetails Optional auth details for the create path (OAuth token or static auth)
-   * @param params.organizationId Optional organization ID
-   * @param params.userId Optional user ID
-   * @param params.apiConfig Optional API config for the create path
-   */
-  async getOrCreateConnectedAccount(params: {
-    connector: string;
-    identifier: string;
-    authorizationDetails?: PartialMessage<AuthorizationDetails>;
-    organizationId?: string;
-    userId?: string;
-    apiConfig?: Record<string, unknown>;
-  }): Promise<CreateConnectedAccountResponse> {
-    const {
-      connector,
-      identifier,
-      authorizationDetails,
-      organizationId,
-      userId,
-      apiConfig,
-    } = params;
-
-    if (!connector?.trim()) {
-      throw new Error("connector is required");
-    }
-    if (!identifier?.trim()) {
-      throw new Error("identifier is required");
-    }
-
-    try {
-      const getResponse = await this.getConnectedAccountByIdentifier({
-        connector,
-        identifier,
-        organizationId,
-        userId,
-      });
-      return new CreateConnectedAccountResponse({
-        connectedAccount: getResponse.connectedAccount,
-      });
-    } catch (err) {
-      if (!(err instanceof ScalekitNotFoundException)) {
-        throw err;
-      }
-    }
-
-    const connectedAccountPayload = new CreateConnectedAccount({
-      authorizationDetails: authorizationDetails
-        ? (authorizationDetails as AuthorizationDetails)
-        : new AuthorizationDetails({
-            details: { case: "oauthToken", value: new OauthToken({}) },
-          }),
-      ...(apiConfig != null && { apiConfig: apiConfig as unknown as CreateConnectedAccount["apiConfig"] }),
-    });
-
-    return this.createConnectedAccount({
-      connector,
-      identifier,
-      connectedAccount: connectedAccountPayload,
-      organizationId,
-      userId,
-    });
-  }
-
-  /**
-   * Updates an existing connected account.
-   *
-   * You can target the account either by `connectedAccountId` or by the combination
-   * of `organizationId`/`userId`, `connector`, and `identifier`.
-   */
-  async updateConnectedAccount(params: {
-    connector: string;
-    identifier: string;
-    connectedAccount: UpdateConnectedAccount;
-    organizationId?: string;
-    userId?: string;
-    connectedAccountId?: string;
-  }): Promise<UpdateConnectedAccountResponse> {
-    const {
-      connector,
-      identifier,
-      connectedAccount,
-      organizationId,
-      userId,
-      connectedAccountId,
-    } = params;
-
-    const request: PartialMessage<UpdateConnectedAccountRequest> = {
-      connector,
-      identifier,
-      connectedAccount,
-    };
-
-    if (organizationId) {
-      request.organizationId = organizationId;
-    }
-    if (userId) {
-      request.userId = userId;
-    }
-    if (connectedAccountId) {
-      request.id = connectedAccountId;
-    }
-
-    return this.coreClient.connectExec(
-      this.client.updateConnectedAccount,
-      request
-    );
-  }
-
-  /**
-   * Deletes a connected account and revokes its credentials.
-   *
-   * You can target the account either by `connectedAccountId` or by the combination
-   * of `organizationId`/`userId`, `connector`, and `identifier`.
-   */
-  async deleteConnectedAccount(params: {
-    connector: string;
-    identifier: string;
-    organizationId?: string;
-    userId?: string;
-    connectedAccountId?: string;
-  }): Promise<DeleteConnectedAccountResponse> {
-    const { connector, identifier, organizationId, userId, connectedAccountId } =
-      params;
-
-    const request: PartialMessage<DeleteConnectedAccountRequest> = {
-      connector,
-      identifier,
-    };
-
-    if (organizationId) {
-      request.organizationId = organizationId;
-    }
-    if (userId) {
-      request.userId = userId;
-    }
-    if (connectedAccountId) {
-      request.id = connectedAccountId;
-    }
-
-    return this.coreClient.connectExec(
-      this.client.deleteConnectedAccount,
-      request
-    );
-  }
-
-  /**
-   * Generates a time-limited magic link for connecting or re-authorizing a third-party account.
-   */
-  async getMagicLinkForConnectedAccount(params: {
-    connector: string;
-    identifier: string;
-    organizationId?: string;
-    userId?: string;
-    connectedAccountId?: string;
-  }): Promise<GetMagicLinkForConnectedAccountResponse> {
-    const { connector, identifier, organizationId, userId, connectedAccountId } =
-      params;
-
-    const request: PartialMessage<GetMagicLinkForConnectedAccountRequest> = {
-      connector,
-      identifier,
-    };
-
-    if (organizationId) {
-      request.organizationId = organizationId;
-    }
-    if (userId) {
-      request.userId = userId;
-    }
-    if (connectedAccountId) {
-      request.id = connectedAccountId;
-    }
-
-    return this.coreClient.connectExec(
-      this.client.getMagicLinkForConnectedAccount,
-      request
-    );
-  }
-
-  /**
-   * Retrieves complete authentication details for a connected account.
-   *
-   * This method returns sensitive credential information, so ensure you protect access
-   * to this in your application.
-   */
-  async getConnectedAccountByIdentifier(params: {
-    connector: string;
-    identifier: string;
-    organizationId?: string;
-    userId?: string;
-    connectedAccountId?: string;
-  }): Promise<GetConnectedAccountByIdentifierResponse> {
-    const { connector, identifier, organizationId, userId, connectedAccountId } =
-      params;
-
-    const request: PartialMessage<GetConnectedAccountByIdentifierRequest> = {
-      connector,
-      identifier,
-    };
-
-    if (organizationId) {
-      request.organizationId = organizationId;
-    }
-    if (userId) {
-      request.userId = userId;
-    }
-    if (connectedAccountId) {
-      request.id = connectedAccountId;
-    }
-
-    return this.coreClient.connectExec(
-      this.client.getConnectedAccountAuth,
-      request
-    );
-  }
-}
-

package/src/connection.ts

@@ -1,267 +0,0 @@
-import { PromiseClient } from "@connectrpc/connect";
-import GrpcConnect from "./connect";
-import CoreClient from "./core";
-import { ConnectionService } from "./pkg/grpc/scalekit/v1/connections/connections_connect";
-import {
-  GetConnectionResponse,
-  ToggleConnectionResponse,
-  ListConnectionsResponse,
-} from "./pkg/grpc/scalekit/v1/connections/connections_pb";
-
-/**
- * Client for managing enterprise SSO connections for organizations.
- *
- * Connections represent the SSO integration between an organization and their identity provider (IdP).
- * Each organization can have an enterprise connection supporting different protocols (SAML, OIDC) and
- * providers (Okta, Azure AD, Google Workspace, etc.). Use this client to retrieve connection details,
- * list connections, and enable/disable them.
- *
- * @example
- * const scalekitClient = new ScalekitClient(envUrl, clientId, clientSecret);
- * const connectionClient = scalekitClient.connection;
- *
- * @see {@link https://docs.scalekit.com/apis/#tag/connections | Connection API Documentation}
- */
-export default class ConnectionClient {
-  private client: PromiseClient<typeof ConnectionService>;
-  constructor(
-    private readonly grpcConncet: GrpcConnect,
-    private readonly coreClient: CoreClient
-  ) {
-    this.client = this.grpcConncet.createClient(ConnectionService);
-  }
-
-  /**
-   * Retrieves complete configuration and status details for a specific SSO connection.
-   *
-   * Use this method to fetch comprehensive information about an organization's SSO connection,
-   * including provider settings, protocol details (SAML/OIDC), enabled status, and configuration
-   * metadata. This is useful for verifying connection setup, auditing configurations, checking
-   * connection health before authentication flows, or displaying connection details to administrators.
-   *
-   * @param {string} organizationId - The organization ID that owns the connection (format: "org_...")
-   * @param {string} id - The connection identifier to retrieve (format: "conn_...")
-   *
-   * @returns {Promise<GetConnectionResponse>} Response containing:
-   *   - connection: Complete connection object with:
-   *     - id: Unique connection identifier
-   *     - organizationId: Parent organization ID
-   *     - provider: Identity provider name (e.g., "okta", "azure_ad", "google")
-   *     - type: Protocol type ("saml", "oidc")
-   *     - enabled: Whether the connection is active
-   *     - status: Configuration status
-   *     - domains: Associated email domains for this connection
-   *     - metadata: Provider-specific configuration details
-   *     - createTime: When the connection was created
-   *     - updateTime: When the connection was last modified
-   *
-   * @throws {Error} If the organization or connection is not found
-   *
-   * @example
-   * // Get connection details
-   * const response = await scalekitClient.connection.getConnection(
-   *   'org_123456',
-   *   'conn_abc123'
-   * );
-   *
-   * const conn = response.connection;
-   * console.log('Provider:', conn.provider);
-   * console.log('Type:', conn.type);
-   * console.log('Status:', conn.enabled ? 'Enabled' : 'Disabled');
-   * console.log('Domains:', conn.domains);
-   *
-   * @example
-   * // Verify connection is ready for authentication
-   * const response = await scalekitClient.connection.getConnection(orgId, connId);
-   *
-   * if (response.connection.enabled && response.connection.status === 'active') {
-   *   console.log('Connection is ready for SSO authentication');
-   * } else {
-   *   console.log('Connection not ready:', response.connection.status);
-   * }
-   *
-   *
-   * @see {@link https://docs.scalekit.com/apis/#tag/connections | Get Connection API}
-   * @see {@link listConnections} - List all connections for an organization
-   * @see {@link enableConnection} - Enable this connection
-   * @see {@link disableConnection} - Disable this connection
-   */
-  async getConnection(
-    organizationId: string,
-    id: string
-  ): Promise<GetConnectionResponse> {
-    return this.coreClient.connectExec(this.client.getConnection, {
-      id,
-      organizationId,
-    });
-  }
-
-  /**
-   * Lists all SSO connections associated with a specific email domain.
-   *
-   * Use this method to discover which organizations have SSO configured for a particular
-   * domain. This is useful for implementing domain-based SSO routing where users are
-   * automatically directed to their organization's SSO based on their email domain.
-   *
-   * @param {string} domain - The email domain to search for (e.g., "acme.com")
-   *
-   * @returns {Promise<ListConnectionsResponse>} Response containing:
-   *   - connections: Array of connection objects for the domain
-   *
-   * @example
-   * // Find SSO connections for a domain
-   * const response = await scalekitClient.connection.listConnectionsByDomain('acme.com');
-   *
-   * if (response.connections.length > 0) {
-   *   console.log('SSO available for domain acme.com');
-   *   const connection = response.connections[0];
-   *   console.log('Organization:', connection.organizationId);
-   *   console.log('Provider:', connection.provider);
-   * }
-   *
-   * @example
-   * // Implement domain-based SSO routing
-   * app.post('/auth/login', async (req, res) => {
-   *   const email = req.body.email;
-   *   const domain = email.split('@')[1];
-   *
-   *   const response = await scalekitClient.connection.listConnectionsByDomain(domain);
-   *
-   *   if (response.connections.length > 0) {
-   *     // Redirect to SSO
-   *     const authUrl = scalekitClient.getAuthorizationUrl(redirectUri, {
-   *       connectionId: response.connections[0].id,
-   *       loginHint: email
-   *     });
-   *     return res.redirect(authUrl);
-   *   } else {
-   *     // Use password-based login
-   *     return res.render('password-login');
-   *   }
-   * });
-   *
-   * @see {@link https://docs.scalekit.com/apis/#tag/connections | List Connections API}
-   * @see {@link listConnections} - List all connections for an organization
-   */
-  async listConnectionsByDomain(
-    domain: string
-  ): Promise<ListConnectionsResponse> {
-    return this.coreClient.connectExec(this.client.listConnections, {
-      domain,
-    });
-  }
-
-  /**
-   * Lists all SSO connections configured for an organization.
-   *
-   * Retrieves all enterprise SSO connections (SAML, OIDC) that have been configured for
-   * the specified organization. Each connection includes details about the provider,
-   * status, and configuration.
-   *
-   * @param {string} organizationId - The organization ID
-   *
-   * @returns {Promise<ListConnectionsResponse>} Response containing:
-   *   - connections: Array of connection objects with provider details and status
-   *
-   * @example
-   * // List all SSO connections for an organization
-   * const response = await scalekitClient.connection.listConnections('org_123456');
-   *
-   * console.log(`Found ${response.connections.length} connections`);
-   * response.connections.forEach(conn => {
-   *   console.log(`- ${conn.provider} (${conn.type}): ${conn.enabled ? 'Enabled' : 'Disabled'}`);
-   * });
-   *
-   * @example
-   * // Check if organization has any enabled connections
-   * const response = await scalekitClient.connection.listConnections('org_123456');
-   * const hasEnabledSSO = response.connections.some(conn => conn.enabled);
-   *
-   * if (!hasEnabledSSO) {
-   *   console.log('No SSO connections enabled for this organization');
-   * }
-   *
-   * @see {@link https://docs.scalekit.com/apis/#tag/connections | List Connections API}
-   * @see {@link getConnection} - Get details of a specific connection
-   * @see {@link enableConnection} - Enable a connection
-   * @see {@link disableConnection} - Disable a connection
-   */
-  async listConnections(
-    organizationId: string
-  ): Promise<ListConnectionsResponse> {
-    return this.coreClient.connectExec(this.client.listConnections, {
-      organizationId,
-    });
-  }
-
-  /**
-   * Enables an SSO connection for an organization.
-   *
-   * Activates a previously disabled or newly configured SSO connection, allowing users
-   * from the organization to authenticate using this identity provider. Once enabled,
-   * users can immediately start using SSO to log in.
-   *
-   * @param {string} organizationId - The organization ID
-   * @param {string} id - The connection ID to enable
-   *
-   * @returns {Promise<ToggleConnectionResponse>} Response with updated connection status
-   *
-   * @example
-   * // Enable an SSO connection
-   * const response = await scalekitClient.connection.enableConnection(
-   *   'org_123456',
-   *   'conn_abc123'
-   * );
-   *
-   * console.log('Connection enabled:', response.connection.enabled); // true
-   *
-   *
-   * @see {@link https://docs.scalekit.com/apis/#tag/connections | Enable Connection API}
-   * @see {@link disableConnection} - Disable a connection
-   * @see {@link listConnections} - List all connections
-   */
-  async enableConnection(
-    organizationId: string,
-    id: string
-  ): Promise<ToggleConnectionResponse> {
-    return this.coreClient.connectExec(this.client.enableConnection, {
-      id,
-      organizationId,
-    });
-  }
-
-  /**
-   * Disables an SSO connection for an organization.
-   *
-   * Deactivates an SSO connection, preventing users from authenticating via this identity
-   * provider. This is useful for temporarily suspending SSO access, during maintenance,
-   * or when migrating to a different provider. Existing user sessions remain valid.
-   *
-   * @param {string} organizationId - The organization ID
-   * @param {string} id - The connection ID to disable
-   *
-   * @returns {Promise<ToggleConnectionResponse>} Response with updated connection status
-   *
-   * @example
-   * // Disable an SSO connection
-   * const response = await scalekitClient.connection.disableConnection(
-   *   'org_123456',
-   *   'conn_abc123'
-   * );
-   *
-   * console.log('Connection disabled:', !response.connection.enabled); // true
-   *
-   * @see {@link https://docs.scalekit.com/apis/#tag/connections | Disable Connection API}
-   * @see {@link enableConnection} - Enable a connection
-   * @see {@link listConnections} - List all connections
-   */
-  async disableConnection(
-    organizationId: string,
-    id: string
-  ): Promise<ToggleConnectionResponse> {
-    return this.coreClient.connectExec(this.client.disableConnection, {
-      id,
-      organizationId,
-    });
-  }
-}

package/src/constants/user.ts

@@ -1,22 +0,0 @@
-import type { IdTokenClaim, User } from '../types/auth';
-
-export const IdTokenClaimToUserMap: { [k in keyof IdTokenClaim]: keyof User } = {
-  "sub": "id",
-  "name": "name",
-  "preferred_username": "username",
-  "given_name": "givenName",
-  "family_name": "familyName",
-  "email": "email",
-  "email_verified": "emailVerified",
-  "phone_number": "phoneNumber",
-  "phone_number_verified": "phoneNumberVerified",
-  "profile": 'profile',
-  "picture": "picture",
-  "gender": "gender",
-  "birthdate": "birthDate",
-  "zoneinfo": "zoneInfo",
-  "locale": "locale",
-  "updated_at": "updatedAt",
-  "identities": "identities",
-  "metadata": "metadata"
-}