@base44-preview/sdk 0.8.30-pr.160.b403af6 → 0.8.31-pr.178.78bd45c

package/dist/client.js

@@ -9,6 +9,7 @@ import { createFunctionsModule } from "./modules/functions.js";
 import { createAgentsModule } from "./modules/agents.js";
 import { createAppLogsModule } from "./modules/app-logs.js";
 import { createUsersModule } from "./modules/users.js";
+import { createAccountsModule } from "./modules/accounts.js";
 import { RoomsSocket } from "./utils/socket-utils.js";
 import { createAnalyticsModule } from "./modules/analytics.js";
 /**
@@ -83,12 +84,14 @@ export function createClient(config) {
         baseURL: `${serverUrl}/api`,
         headers,
         token,
+        appId: String(appId),
         onError: options === null || options === void 0 ? void 0 : options.onError,
     });
     const functionsAxiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
         headers: functionHeaders,
         token,
+        appId: String(appId),
         interceptResponses: false,
         onError: options === null || options === void 0 ? void 0 : options.onError,
     });
@@ -100,12 +103,14 @@ export function createClient(config) {
         baseURL: `${serverUrl}/api`,
         headers: serviceRoleHeaders,
         token: serviceToken,
+        appId: String(appId),
         onError: options === null || options === void 0 ? void 0 : options.onError,
     });
     const serviceRoleFunctionsAxiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
         headers: functionHeaders,
         token: serviceToken,
+        appId: String(appId),
         interceptResponses: false,
     });
     const userAuthModule = createAuthModule(axiosClient, functionsAxiosClient, appId, {
@@ -152,6 +157,7 @@ export function createClient(config) {
         }),
         appLogs: createAppLogsModule(axiosClient, appId),
         users: createUsersModule(axiosClient, appId),
+        accounts: createAccountsModule(axiosClient, appId),
         analytics: createAnalyticsModule({
             axiosClient,
             serverUrl,

package/dist/client.types.d.ts

@@ -7,6 +7,7 @@ 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";
 import type { AnalyticsModule } from "./modules/analytics.types.js";
+import type { AccountsModule } from "./modules/accounts.types.js";
 /**
  * Options for creating a Base44 client.
  */
@@ -79,6 +80,8 @@ export interface CreateClientConfig {
  * Provides access to all SDK modules for interacting with the app.
  */
 export interface Base44Client {
+    /** {@link AccountsModule | Accounts module} for multi-tenancy (accounts, members, billing). */
+    accounts: AccountsModule;
     /** {@link AgentsModule | Agents module} for managing AI agent conversations. */
     agents: AgentsModule;
     /** {@link AnalyticsModule | Analytics module} for tracking custom events in your app. */

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export type { IntegrationsModule, IntegrationEndpointFunction, CoreIntegrations,
 export type { FunctionsModule, FunctionName, FunctionNameRegistry, } from "./modules/functions.types.js";
 export type { AgentsModule, AgentName, AgentNameRegistry, AgentConversation, AgentMessage, AgentMessageReasoning, AgentMessageToolCall, AgentMessageUsage, AgentMessageCustomContext, AgentMessageMetadata, CreateConversationParams, } from "./modules/agents.types.js";
 export type { AppLogsModule } from "./modules/app-logs.types.js";
+export type { AccountsModule, Account, AccountMembership, AccountPlan, AccountRole, AssignableAccountRole, AccountStatus, AccountMembershipStatus, MyAccountsResponse, CheckoutSession, } from "./modules/accounts.types.js";
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
 export type { ConnectorsModule, UserConnectorsModule, } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";

package/dist/modules/accounts.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from "axios";
+import type { AccountsModule } from "./accounts.types.js";
+/**
+ * Creates the accounts module (multi-tenancy) for the Base44 SDK.
+ *
+ * @param axios - Axios instance (responses are unwrapped to data).
+ * @param appId - Application ID.
+ * @returns The accounts module.
+ * @internal
+ */
+export declare function createAccountsModule(axios: AxiosInstance, appId: string): AccountsModule;

package/dist/modules/accounts.js

@@ -0,0 +1,61 @@
+import { getActiveAccountIdFromPath } from "../utils/common.js";
+/**
+ * Creates the accounts module (multi-tenancy) for the Base44 SDK.
+ *
+ * @param axios - Axios instance (responses are unwrapped to data).
+ * @param appId - Application ID.
+ * @returns The accounts module.
+ * @internal
+ */
+export function createAccountsModule(axios, appId) {
+    const base = `/apps/${appId}/accounts`;
+    const enc = encodeURIComponent;
+    return {
+        getActiveAccountId() {
+            return getActiveAccountIdFromPath(appId);
+        },
+        switchAccount(accountId, subPath = "") {
+            if (typeof window === "undefined")
+                return;
+            const clean = subPath.replace(/^\/+/, "");
+            window.location.assign(`/${accountId}${clean ? `/${clean}` : "/"}`);
+        },
+        async listMine() {
+            return axios.get(`${base}/me`);
+        },
+        async create(params) {
+            return axios.post(base, params);
+        },
+        async update(accountId, params) {
+            return axios.patch(`${base}/${accountId}`, params);
+        },
+        async listMembers(accountId) {
+            return axios.get(`${base}/${accountId}/members`);
+        },
+        async invite(accountId, email, role = "member") {
+            return axios.post(`${base}/${accountId}/invites`, { email, role });
+        },
+        async acceptInvite(accountId) {
+            return axios.post(`${base}/${accountId}/accept`, {});
+        },
+        async changeMemberRole(accountId, email, role) {
+            return axios.patch(`${base}/${accountId}/members/${enc(email)}/role`, {
+                role,
+            });
+        },
+        async removeMember(accountId, email) {
+            return axios.delete(`${base}/${accountId}/members/${enc(email)}`);
+        },
+        async transferOwnership(accountId, email) {
+            return axios.post(`${base}/${accountId}/transfer-ownership`, { email });
+        },
+        billing: {
+            async listPlans(accountId) {
+                return axios.get(`${base}/${accountId}/billing/plans`);
+            },
+            async startCheckout(accountId, params) {
+                return axios.post(`${base}/${accountId}/billing/checkout`, params);
+            },
+        },
+    };
+}

package/dist/modules/accounts.types.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Types for the {@link AccountsModule | accounts} module (multi-tenancy).
+ *
+ * An Account groups the app's end-users into an isolated tenant (a company,
+ * team, or organization). Users join accounts via membership and act inside one
+ * active account at a time. Account-scoped entities are transparently isolated
+ * to the active account (carried by the `X-Active-Account-Id` header, derived
+ * from the `/<account_id>/...` URL path).
+ */
+/** Account-management role. Distinct from the app's business roles. */
+export type AccountRole = "owner" | "admin" | "member";
+/** Assignable (non-owner) role used for invites/role changes. */
+export type AssignableAccountRole = "admin" | "member";
+export type AccountStatus = "active" | "suspended";
+export type AccountMembershipStatus = "pending" | "active";
+/** An account (tenant) within the app. */
+export interface Account {
+    id: string;
+    app_id: string;
+    name: string;
+    status: AccountStatus;
+    plan_id?: string | null;
+    billing_status?: string;
+    /** The current user's role in this account (present on `listMine()` results). */
+    my_role?: AccountRole;
+    /** Builder-defined custom fields. */
+    data?: Record<string, unknown>;
+    created_date?: string;
+}
+/** The accounts the current user belongs to, plus the active one. */
+export interface MyAccountsResponse {
+    accounts: Account[];
+    active_account_id: string | null;
+}
+/** A user's membership in an account. */
+export interface AccountMembership {
+    id: string;
+    account_id: string;
+    email: string;
+    role: AccountRole;
+    status: AccountMembershipStatus;
+}
+/** A subscription plan/tier offered to accounts. */
+export interface AccountPlan {
+    id: string;
+    name: string;
+    description?: string | null;
+    price_amount: number;
+    currency: string;
+    interval: "month" | "year";
+    is_active: boolean;
+}
+/** A provider checkout session. */
+export interface CheckoutSession {
+    url: string;
+    session_id: string;
+}
+/**
+ * The accounts module — manage multi-tenancy ("Accounts") from inside the app.
+ *
+ * Access via `base44.accounts`. Available when the app has multi-tenancy enabled.
+ */
+export interface AccountsModule {
+    /** The active account id, read from the current URL path (or `undefined`). */
+    getActiveAccountId(): string | undefined;
+    /**
+     * Switch the active account by navigating to its folder (`/<accountId>/...`).
+     * A full navigation re-roots the app so all data follows the new account.
+     * @param accountId - The account to switch to.
+     * @param subPath - Optional in-account route to land on (defaults to the root).
+     */
+    switchAccount(accountId: string, subPath?: string): void;
+    /** List the accounts the current user belongs to, plus the active one. */
+    listMine(): Promise<MyAccountsResponse>;
+    /** Create a new account; the current user becomes its owner. */
+    create(params: {
+        name: string;
+        data?: Record<string, unknown>;
+    }): Promise<Account>;
+    /** Rename and/or update an account's custom fields (managers only). */
+    update(accountId: string, params: {
+        name?: string;
+        data?: Record<string, unknown>;
+    }): Promise<Account>;
+    /** List an account's members (any active member). */
+    listMembers(accountId: string): Promise<AccountMembership[]>;
+    /** Invite a user by email to an account (managers only). */
+    invite(accountId: string, email: string, role?: AssignableAccountRole): Promise<AccountMembership>;
+    /** Accept a pending invite to an account for the current user. */
+    acceptInvite(accountId: string): Promise<AccountMembership>;
+    /** Change a member's role (managers only; not for the owner). */
+    changeMemberRole(accountId: string, email: string, role: AssignableAccountRole): Promise<AccountMembership>;
+    /** Remove a member from an account (managers only; not the owner). */
+    removeMember(accountId: string, email: string): Promise<{
+        removed: boolean;
+    }>;
+    /** Transfer ownership to another active member (owner only). */
+    transferOwnership(accountId: string, email: string): Promise<{
+        transferred: boolean;
+    }>;
+    /** Per-account billing. */
+    billing: {
+        /** List the active plans available to this account. */
+        listPlans(accountId: string): Promise<AccountPlan[]>;
+        /** Start a subscription checkout session for a plan. */
+        startCheckout(accountId: string, params: {
+            plan_id: string;
+            success_url: string;
+            cancel_url: string;
+        }): Promise<CheckoutSession>;
+    };
+}

package/dist/modules/accounts.types.js

@@ -0,0 +1,10 @@
+/**
+ * Types for the {@link AccountsModule | accounts} module (multi-tenancy).
+ *
+ * An Account groups the app's end-users into an isolated tenant (a company,
+ * team, or organization). Users join accounts via membership and act inside one
+ * active account at a time. Account-scoped entities are transparently isolated
+ * to the active account (carried by the `X-Active-Account-Id` header, derived
+ * from the `/<account_id>/...` URL path).
+ */
+export {};

package/dist/modules/connectors.js

@@ -21,25 +21,24 @@ export function createConnectorsModule(axios, appId) {
             // @ts-expect-error
             return response.access_token;
         },
-        async getConnection(arg) {
+        async getConnection(integrationType) {
             var _a;
-            let url;
-            if (typeof arg === "string") {
-                if (!arg) {
-                    throw new Error("Integration type is required and must be a string");
-                }
-                url = `/apps/${appId}/external-auth/tokens/${arg}`;
-            }
-            else if (arg && typeof arg === "object" && typeof arg.connectorId === "string") {
-                if (!arg.connectorId) {
-                    throw new Error("Connector ID is required and must be a string");
-                }
-                url = `/apps/${appId}/external-auth/tokens/by-connector/${arg.connectorId}`;
+            if (!integrationType || typeof integrationType !== "string") {
+                throw new Error("Integration type is required and must be a string");
             }
-            else {
-                throw new Error("getConnection requires either an integration type string or an object with a connectorId string");
+            const response = await axios.get(`/apps/${appId}/external-auth/tokens/${integrationType}`);
+            const data = response;
+            return {
+                accessToken: data.access_token,
+                connectionConfig: (_a = data.connection_config) !== null && _a !== void 0 ? _a : null,
+            };
+        },
+        async getWorkspaceConnection(connectorId) {
+            var _a;
+            if (!connectorId || typeof connectorId !== "string") {
+                throw new Error("Connector ID is required and must be a string");
             }
-            const response = await axios.get(url);
+            const response = await axios.get(`/apps/${appId}/external-auth/tokens/connectors/${connectorId}`);
             const data = response;
             return {
                 accessToken: data.access_token,

package/dist/modules/connectors.types.d.ts

@@ -255,30 +255,28 @@ export interface ConnectorsModule {
      * Retrieves the OAuth access token and connection configuration for a **workspace-registered** connector
      * (a connector backed by an OAuth app registered in the workspace, consented to once by the app builder).
      *
-     * Use this overload when the app's backend function needs to use a connector identified by its
+     * Use this method when the app's backend function needs to use a connector identified by its
      * workspace-connector ID rather than a platform integration type. The token returned represents
      * the app builder's consent against the workspace's OAuth app and is shared across all app users
-     * of the app — identical semantics to the platform-shared `getConnection(integrationType)` form,
+     * of the app — identical semantics to the platform-shared {@link getConnection} form,
      * differing only in which OAuth app was used to produce the token.
      *
-     * @param opts - An object with `connectorId` — the ID of the workspace connector (the `OrganizationConnector` database ID) as surfaced in the builder chat context.
+     * @param connectorId - The ID of the workspace connector (the `OrganizationConnector` database ID) as surfaced in the builder chat context.
      * @returns Promise resolving to a {@link ConnectorConnectionResponse} with `accessToken` and `connectionConfig`.
      *
      * @example
      * ```typescript
      * // Get the connection for a workspace-registered connector
-     * const { accessToken, connectionConfig } = await base44.asServiceRole.connectors.getConnection({
-     *   connectorId: 'abc123def',
-     * });
+     * const { accessToken, connectionConfig } = await base44.asServiceRole.connectors.getWorkspaceConnection(
+     *   'abc123def',
+     * );
      *
      * const response = await fetch(`https://${connectionConfig?.subdomain}.snowflakecomputing.com/api/v2/statements`, {
      *   headers: { Authorization: `Bearer ${accessToken}` },
      * });
      * ```
      */
-    getConnection(opts: {
-        connectorId: string;
-    }): Promise<ConnectorConnectionResponse>;
+    getWorkspaceConnection(connectorId: string): Promise<ConnectorConnectionResponse>;
     /**
      * @internal
      * @deprecated Use {@link getCurrentAppUserConnection} instead.

package/dist/utils/axios-client.d.ts

@@ -90,10 +90,11 @@ export declare class Base44Error extends Error {
  * @returns Configured axios instance
  * @internal
  */
-export declare function createAxiosClient({ baseURL, headers, token, interceptResponses, onError, }: {
+export declare function createAxiosClient({ baseURL, headers, token, appId, interceptResponses, onError, }: {
     baseURL: string;
     headers?: Record<string, string>;
     token?: string;
+    appId?: string;
     interceptResponses?: boolean;
     onError?: (error: Error) => void;
 }): import("axios").AxiosInstance;

package/dist/utils/axios-client.js

@@ -1,5 +1,5 @@
 import axios from "axios";
-import { isInIFrame } from "./common.js";
+import { getActiveAccountIdFromPath, isInIFrame } from "./common.js";
 import { v4 as uuidv4 } from "uuid";
 /**
  * Custom error class for Base44 SDK errors.
@@ -114,7 +114,7 @@ function safeErrorLog(prefix, error) {
  * @returns Configured axios instance
  * @internal
  */
-export function createAxiosClient({ baseURL, headers = {}, token, interceptResponses = true, onError, }) {
+export function createAxiosClient({ baseURL, headers = {}, token, appId, interceptResponses = true, onError, }) {
     const client = axios.create({
         baseURL,
         headers: {
@@ -131,6 +131,16 @@ export function createAxiosClient({ baseURL, headers = {}, token, interceptRespo
     client.interceptors.request.use((config) => {
         if (typeof window !== "undefined") {
             config.headers.set("X-Origin-URL", window.location.href);
+            // Multi-tenancy: forward the active account (from the URL path) per request
+            // so account-scoped reads/writes stay isolated to the current tenant even
+            // after a client-side account switch. The path is the canonical source, so
+            // it overrides any stale default header (e.g. one frozen at module load);
+            // no-op for single-tenant apps (no account segment in the path). The app id
+            // is passed so the sandbox base path (/<appId>/) is never read as an account.
+            const activeAccountId = getActiveAccountIdFromPath(appId);
+            if (activeAccountId) {
+                config.headers.set("X-Active-Account-Id", activeAccountId);
+            }
         }
         const requestId = uuidv4();
         config.requestId = requestId;

package/dist/utils/common.d.ts

@@ -1,3 +1,12 @@
 export declare const isNode: boolean;
 export declare const isInIFrame: boolean;
+/**
+ * The active account id from the URL, or undefined.
+ *
+ * In the sandbox/preview the app is served under `/<appId>/` (the dev-server base
+ * path), so the first segment is the app id — its own base, NOT an account. When
+ * `appId` is supplied and matches the leading segment, it's skipped so the app id
+ * is never sent as an account id; the account, if any, is the next segment.
+ */
+export declare function getActiveAccountIdFromPath(appId?: string): string | undefined;
 export declare const generateUuid: () => string;

package/dist/utils/common.js

@@ -1,5 +1,25 @@
 export const isNode = typeof window === "undefined";
 export const isInIFrame = !isNode && window.self !== window.top;
+// Multi-tenancy: apps are served under `/<account_id>/<route>` where the first
+// path segment is a 24-hex Mongo ObjectId. Read it at request time so the active
+// account is always current — even after client-side (Link/useNavigate) account
+// switches that don't reload the module.
+const ACCOUNT_ID_RE = /^[a-f0-9]{24}$/;
+/**
+ * The active account id from the URL, or undefined.
+ *
+ * In the sandbox/preview the app is served under `/<appId>/` (the dev-server base
+ * path), so the first segment is the app id — its own base, NOT an account. When
+ * `appId` is supplied and matches the leading segment, it's skipped so the app id
+ * is never sent as an account id; the account, if any, is the next segment.
+ */
+export function getActiveAccountIdFromPath(appId) {
+    if (isNode)
+        return undefined;
+    const segments = window.location.pathname.split("/").filter(Boolean);
+    const candidate = appId && segments[0] === appId ? segments[1] : segments[0];
+    return candidate && ACCOUNT_ID_RE.test(candidate) ? candidate : undefined;
+}
 export const generateUuid = () => {
     return (Math.random().toString(36).substring(2, 15) +
         Math.random().toString(36).substring(2, 15));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.30-pr.160.b403af6",
+  "version": "0.8.31-pr.178.78bd45c",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",