@base44-preview/sdk 0.8.30-pr.160.b403af6 → 0.8.31-pr.178.4dde9c5

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,100 @@
+import { getStoredActiveAccountId, setStoredActiveAccountId, } 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;
+    // Resolve the account id to operate on: an explicit id wins, then the
+    // explicitly-stored client selection, then the server-resolved default
+    // (the sole-account case). Throws a clear error when none can be found so
+    // callers never silently send `/accounts/undefined/...` (which 404s as
+    // "Account not found").
+    const resolveAccountId = async (provided) => {
+        if (provided)
+            return provided;
+        const stored = getStoredActiveAccountId(appId);
+        if (stored)
+            return stored;
+        const mine = await axios.get(`${base}/me`);
+        if (mine.active_account_id)
+            return mine.active_account_id;
+        throw new Error("No active account: pass an accountId, or have the user select or create an account first.");
+    };
+    return {
+        getActiveAccountId() {
+            return getStoredActiveAccountId(appId);
+        },
+        switchAccount(accountId) {
+            setStoredActiveAccountId(appId, accountId);
+            if (typeof window === "undefined")
+                return;
+            window.location.reload();
+        },
+        setActiveAccount(accountId) {
+            setStoredActiveAccountId(appId, accountId);
+        },
+        clearActiveAccount() {
+            setStoredActiveAccountId(appId, null);
+        },
+        async listMine() {
+            return axios.get(`${base}/me`);
+        },
+        async getPublicAccount(slug) {
+            return axios.get(`${base}/public/by-slug/${enc(slug)}`);
+        },
+        async joinAccount(slug) {
+            return axios.post(`${base}/by-slug/${enc(slug)}/join`, {});
+        },
+        async create(params) {
+            return axios.post(base, params);
+        },
+        async update(accountId, params) {
+            return axios.patch(`${base}/${accountId}`, params);
+        },
+        async listMembers(accountId) {
+            const id = await resolveAccountId(accountId);
+            return axios.get(`${base}/${id}/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) {
+                const id = await resolveAccountId(accountId);
+                return axios.get(`${base}/${id}/billing/plans`);
+            },
+            async getSubscription(accountId) {
+                const id = await resolveAccountId(accountId);
+                return axios.get(`${base}/${id}/billing/subscription`);
+            },
+            async startCheckout(accountIdOrParams, maybeParams) {
+                const explicitId = typeof accountIdOrParams === "string" ? accountIdOrParams : undefined;
+                const params = typeof accountIdOrParams === "string"
+                    ? maybeParams
+                    : accountIdOrParams;
+                const id = await resolveAccountId(explicitId);
+                return axios.post(`${base}/${id}/billing/checkout`, params);
+            },
+        },
+    };
+}

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

@@ -0,0 +1,181 @@
+/**
+ * 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, read from
+ * stored client state in localStorage, keyed per app).
+ */
+/** 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;
+}
+/**
+ * Public, unauthenticated view of an account (its landing page), resolved by
+ * slug. Carries identity plus only the builder-designated public custom fields.
+ */
+export interface PublicAccount {
+    id: string;
+    name: string;
+    slug: string | null;
+    /** Builder-flagged public companion fields (e.g. logo, tagline). */
+    data: Record<string, unknown>;
+}
+/** 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;
+}
+/** Parameters for starting a subscription checkout. */
+export interface CheckoutParams {
+    plan_id: string;
+    success_url: string;
+    cancel_url: string;
+}
+/** The current subscription state of an account. */
+export interface AccountSubscription {
+    account_id: string;
+    /** The active plan id, or `null` when the account has no subscription. */
+    plan_id: string | null;
+    /** Lifecycle status: "none" | "active" | "past_due" | "canceled". */
+    billing_status: string;
+    /** The payment rail backing the subscription, or `null`. */
+    billing_provider: string | null;
+    /** The current plan, or `null` when the account has no subscription. */
+    plan: AccountPlan | null;
+    /** When the current paid period ends / renews (ISO 8601), or `null`. */
+    current_period_end: string | null;
+    /** True when the subscription will not renew at period end. */
+    cancel_at_period_end: boolean;
+    /** When the subscription was canceled (ISO 8601), or `null`. */
+    canceled_at: string | null;
+    /** When the subscription started (ISO 8601), or `null`. */
+    started_at: string | null;
+}
+/**
+ * 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 stored client state (or `undefined`). */
+    getActiveAccountId(): string | undefined;
+    /**
+     * Switch the active account by persisting it to stored client state and
+     * reloading the page so all data follows the new account.
+     * @param accountId - The account to switch to.
+     */
+    switchAccount(accountId: string): void;
+    /**
+     * Persist the active account WITHOUT reloading the page.
+     *
+     * Use on the public landing page to select the account before redirecting to
+     * login, so the app resolves that account after the visitor returns. For
+     * switching accounts inside the running app, use {@link switchAccount} (which
+     * reloads so all data follows the new account).
+     */
+    setActiveAccount(accountId: string): void;
+    /** Clear the stored active account (the backend falls back to the default). */
+    clearActiveAccount(): void;
+    /** List the accounts the current user belongs to, plus the active one. */
+    listMine(): Promise<MyAccountsResponse>;
+    /**
+     * Resolve a public account by its slug (unauthenticated) for its landing page.
+     * @param slug - The account's URL slug.
+     */
+    getPublicAccount(slug: string): Promise<PublicAccount>;
+    /**
+     * Self-join an account by slug (the current user becomes a member). Requires
+     * login and that the app enables public joining; otherwise rejects.
+     * @param slug - The account's URL slug.
+     */
+    joinAccount(slug: string): Promise<AccountMembership>;
+    /** 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).
+     * @param accountId - Defaults to the active account when omitted.
+     */
+    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 an account.
+         * @param accountId - Defaults to the active account when omitted.
+         */
+        listPlans(accountId?: string): Promise<AccountPlan[]>;
+        /**
+         * Get the current subscription state (plan + status) of an account.
+         * @param accountId - Defaults to the active account when omitted.
+         */
+        getSubscription(accountId?: string): Promise<AccountSubscription>;
+        /**
+         * Start a subscription checkout session for a plan, then redirect the
+         * browser to the returned `url`. The account defaults to the active one.
+         */
+        startCheckout(params: CheckoutParams): Promise<CheckoutSession>;
+        startCheckout(accountId: string, params: CheckoutParams): 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, read from
+ * stored client state in localStorage, keyed per app).
+ */
+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 { getStoredActiveAccountId, 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 stored client state
+            // (localStorage, keyed per app) on every request so account-scoped
+            // reads/writes stay isolated to the current tenant. No-op when unset —
+            // the backend then defaults to the user's sole active account.
+            const activeAccountId = appId
+                ? getStoredActiveAccountId(appId)
+                : undefined;
+            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,19 @@
 export declare const isNode: boolean;
 export declare const isInIFrame: boolean;
+/**
+ * The active account id from stored client state, or undefined.
+ *
+ * Browser-only: reads `localStorage['base44:active_account:<appId>']` and returns
+ * it when it's a valid 24-hex account id, else undefined. Returns undefined in
+ * non-browser environments or if storage access throws.
+ */
+export declare function getStoredActiveAccountId(appId: string): string | undefined;
+/**
+ * Persist (or clear) the active account id in stored client state.
+ *
+ * Browser-only: writes `localStorage['base44:active_account:<appId>']` when
+ * `accountId` is a valid 24-hex id, and removes the key when it is null or
+ * invalid. No-op in non-browser environments or if storage access throws.
+ */
+export declare function setStoredActiveAccountId(appId: string, accountId: string | null): void;
 export declare const generateUuid: () => string;

package/dist/utils/common.js

@@ -1,5 +1,53 @@
 export const isNode = typeof window === "undefined";
 export const isInIFrame = !isNode && window.self !== window.top;
+// Multi-tenancy: the active account is explicit client state, not the URL path.
+// It is persisted in localStorage keyed per app (`base44:active_account:<appId>`)
+// so it survives reloads and works under any base path (e.g. the sandbox/preview
+// where the app is served under a non-account base path). When unset, no header
+// is sent and the backend defaults to the user's sole active account.
+const ACCOUNT_ID_RE = /^[a-f0-9]{24}$/;
+const activeAccountStorageKey = (appId) => `base44:active_account:${appId}`;
+/**
+ * The active account id from stored client state, or undefined.
+ *
+ * Browser-only: reads `localStorage['base44:active_account:<appId>']` and returns
+ * it when it's a valid 24-hex account id, else undefined. Returns undefined in
+ * non-browser environments or if storage access throws.
+ */
+export function getStoredActiveAccountId(appId) {
+    if (isNode)
+        return undefined;
+    try {
+        const stored = window.localStorage.getItem(activeAccountStorageKey(appId));
+        return stored && ACCOUNT_ID_RE.test(stored) ? stored : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * Persist (or clear) the active account id in stored client state.
+ *
+ * Browser-only: writes `localStorage['base44:active_account:<appId>']` when
+ * `accountId` is a valid 24-hex id, and removes the key when it is null or
+ * invalid. No-op in non-browser environments or if storage access throws.
+ */
+export function setStoredActiveAccountId(appId, accountId) {
+    if (isNode)
+        return;
+    try {
+        const key = activeAccountStorageKey(appId);
+        if (accountId && ACCOUNT_ID_RE.test(accountId)) {
+            window.localStorage.setItem(key, accountId);
+        }
+        else {
+            window.localStorage.removeItem(key);
+        }
+    }
+    catch (_a) {
+        /* storage unavailable — ignore */
+    }
+}
 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.4dde9c5",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",