new public api

Author: cowchimp

src/client.ts

@@ -3,7 +3,10 @@ import { createEntitiesModule } from "./modules/entities.js";
 import { createIntegrationsModule } from "./modules/integrations.js";
 import { createAuthModule } from "./modules/auth.js";
 import { createSsoModule } from "./modules/sso.js";
-import { createConnectorsModule } from "./modules/connectors.js";
+import {
+  createConnectorsModule,
+  createUserConnectorsModule,
+} from "./modules/connectors.js";
 import { getAccessToken } from "./utils/auth-utils.js";
 import { createFunctionsModule } from "./modules/functions.js";
 import { createAgentsModule } from "./modules/agents.js";
@@ -151,7 +154,7 @@ export function createClient(config: CreateClientConfig): Base44Client {
       getSocket,
     }),
     integrations: createIntegrationsModule(axiosClient, appId),
-    connectors: createConnectorsModule(axiosClient, appId),
+    connectors: createUserConnectorsModule(axiosClient, appId),
     auth: userAuthModule,
     functions: createFunctionsModule(functionsAxiosClient, appId),
     agents: createAgentsModule({

src/client.types.ts

@@ -3,7 +3,10 @@ import type { EntitiesModule } from "./modules/entities.types.js";
 import type { IntegrationsModule } from "./modules/integrations.types.js";
 import type { AuthModule } from "./modules/auth.types.js";
 import type { SsoModule } from "./modules/sso.types.js";
-import type { ConnectorsModule } from "./modules/connectors.types.js";
+import type {
+  ConnectorsModule,
+  UserConnectorsModule,
+} from "./modules/connectors.types.js";
 import type { FunctionsModule } from "./modules/functions.types.js";
 import type { AgentsModule } from "./modules/agents.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
@@ -88,8 +91,8 @@ export interface Base44Client {
   auth: AuthModule;
   /** The underlying Axios instance used for API requests. Useful for making custom API calls with the same authentication and configuration as the SDK. */
   axiosClient: AxiosInstance;
-  /** {@link ConnectorsModule | Connectors module} for OAuth token retrieval. */
-  connectors: ConnectorsModule;
+  /** {@link UserConnectorsModule | Connectors module} for end-user OAuth flows. */
+  connectors: UserConnectorsModule;
   /** {@link EntitiesModule | Entities module} for CRUD operations on your data models. */
   entities: EntitiesModule;
   /** {@link FunctionsModule | Functions module} for invoking custom backend functions. */

src/index.ts

@@ -101,7 +101,10 @@ export type { AppLogsModule } from "./modules/app-logs.types.js";
 
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
 
-export type { ConnectorsModule } from "./modules/connectors.types.js";
+export type {
+  ConnectorsModule,
+  UserConnectorsModule,
+} from "./modules/connectors.types.js";
 
 export type {
   CustomIntegrationsModule,

src/modules/connectors.ts

@@ -4,6 +4,7 @@ import {
   ConnectorAccessTokenResponse,
   ConnectorInitiateResponse,
   ConnectorsModule,
+  UserConnectorsModule,
 } from "./connectors.types.js";
 
 /**
@@ -35,8 +36,39 @@ export function createConnectorsModule(
       // @ts-expect-error
       return response.access_token;
     },
+  };
+}
+
+/**
+ * Creates the user-scoped Connectors module (end-user OAuth flows).
+ *
+ * @param axios - Axios instance (user-scoped client)
+ * @param appId - Application ID
+ * @returns User connectors module with end-user OAuth methods
+ * @internal
+ */
+export function createUserConnectorsModule(
+  axios: AxiosInstance,
+  appId: string
+): UserConnectorsModule {
+  return {
+    // @ts-expect-error Return type mismatch - implementation returns object, interface expects string
+    async getEndUserAccessToken(
+      integrationType: ConnectorIntegrationType
+    ): Promise<ConnectorAccessTokenResponse> {
+      if (!integrationType || typeof integrationType !== "string") {
+        throw new Error("Integration type is required and must be a string");
+      }
+
+      const response = await axios.get<ConnectorAccessTokenResponse>(
+        `/apps/${appId}/end-user-auth/tokens/${integrationType}`
+      );
+
+      // @ts-expect-error
+      return response.access_token;
+    },
 
-    async initiate(
+    async connectEndUser(
       integrationType: ConnectorIntegrationType
     ): Promise<string> {
       if (!integrationType || typeof integrationType !== "string") {
@@ -52,7 +84,7 @@ export function createConnectorsModule(
       return response.redirect_url;
     },
 
-    async disconnect(
+    async disconnectEndUser(
       integrationType: ConnectorIntegrationType
     ): Promise<void> {
       if (!integrationType || typeof integrationType !== "string") {

src/modules/connectors.types.ts

@@ -32,7 +32,7 @@ export interface ConnectorInitiateResponse {
 }
 
 /**
- * Connectors module for managing OAuth tokens for external services.
+ * Connectors module for managing app-scoped OAuth tokens for external services.
  *
  * This module allows you to retrieve OAuth access tokens for external services that the app has connected to. Connectors are app-scoped. When an app builder connects an integration like Google Calendar or Slack, all users of the app share that same connection.
  *
@@ -41,7 +41,7 @@ export interface ConnectorInitiateResponse {
  * the API calls you make. This is useful when you need custom API interactions that aren't
  * covered by Base44's pre-built integrations.
  *
- * This module is only available to use with a client in service role authentication mode, which means it can only be used in backend environments.
+ * This module is only available via `base44.asServiceRole.connectors`.
  *
  * ## Dynamic Types
  *
@@ -92,41 +92,79 @@ export interface ConnectorsModule {
    * ```
    */
   getAccessToken(integrationType: ConnectorIntegrationType): Promise<string>;
+}
+
+/**
+ * User-scoped connectors module for managing end-user OAuth connections.
+ *
+ * This module provides methods for end-user OAuth flows: initiating an OAuth connection,
+ * retrieving the end user's access token, and disconnecting the end user's connection.
+ *
+ * Unlike {@link ConnectorsModule | ConnectorsModule} which manages app-scoped tokens,
+ * this module manages tokens scoped to individual end users.
+ *
+ * Available via `base44.connectors`.
+ *
+ * ## Dynamic Types
+ *
+ * If you're working in a TypeScript project, you can generate types from your app's connector configurations to get autocomplete on integration type names. See the [Dynamic Types](/developers/references/sdk/getting-started/dynamic-types) guide to get started.
+ */
+export interface UserConnectorsModule {
+  /**
+   * Retrieves an OAuth access token for an end user's connection to a specific external integration.
+   *
+   * Returns the OAuth token string that belongs to the currently authenticated end user
+   * for the specified external service.
+   *
+   * @param integrationType - The type of integration, such as `'googlecalendar'`, `'slack'`, or `'github'`.
+   * @returns Promise resolving to the access token string.
+   *
+   * @example
+   * ```typescript
+   * // Get the end user's Google Calendar token
+   * const token = await base44.connectors.getEndUserAccessToken('googlecalendar');
+   *
+   * const response = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events', {
+   *   headers: { 'Authorization': `Bearer ${token}` }
+   * });
+   * ```
+   */
+  getEndUserAccessToken(integrationType: ConnectorIntegrationType): Promise<string>;
 
   /**
    * Initiates the end-user OAuth flow for a specific external integration type.
    *
-   * Returns a redirect URL that the end user should be redirected to in order to
+   * Returns a redirect URL that the end user should be navigated to in order to
    * authenticate with the external service.
    *
    * @param integrationType - The type of integration, such as `'googlecalendar'`, `'slack'`, or `'github'`.
    * @returns Promise resolving to the redirect URL string.
    *
    * @example
    * ```typescript
-   * // Initiate Google Calendar OAuth for the end user
-   * const redirectUrl = await base44.asServiceRole.connectors.initiate('googlecalendar');
+   * // Start Google Calendar OAuth for the end user
+   * const redirectUrl = await base44.connectors.connectEndUser('googlecalendar');
    *
    * // Redirect the user to the OAuth provider
-   * res.redirect(redirectUrl);
+   * window.location.href = redirectUrl;
    * ```
    */
-  initiate(integrationType: ConnectorIntegrationType): Promise<string>;
+  connectEndUser(integrationType: ConnectorIntegrationType): Promise<string>;
 
   /**
-   * Disconnects an end-user's OAuth connection for a specific external integration type.
+   * Disconnects an end user's OAuth connection for a specific external integration type.
    *
-   * Removes the stored OAuth credentials for the end user's connection to the
-   * specified external service.
+   * Removes the stored OAuth credentials for the currently authenticated end user's
+   * connection to the specified external service.
    *
    * @param integrationType - The type of integration to disconnect, such as `'googlecalendar'`, `'slack'`, or `'github'`.
    * @returns Promise resolving when the connection has been removed.
    *
    * @example
    * ```typescript
-   * // Disconnect Google Calendar for the end user
-   * await base44.asServiceRole.connectors.disconnect('googlecalendar');
+   * // Disconnect the end user's Google Calendar connection
+   * await base44.connectors.disconnectEndUser('googlecalendar');
    * ```
    */
-  disconnect(integrationType: ConnectorIntegrationType): Promise<void>;
+  disconnectEndUser(integrationType: ConnectorIntegrationType): Promise<void>;
 }