@base44-preview/sdk 0.8.31-pr.178.78bd45c → 0.8.31-pr.178.837440f

package/dist/modules/accounts.js

@@ -1,4 +1,4 @@
-import { getActiveAccountIdFromPath } from "../utils/common.js";
+import { getStoredActiveAccountId, setStoredActiveAccountId, } from "../utils/common.js";
 /**
  * Creates the accounts module (multi-tenancy) for the Base44 SDK.
  *
@@ -10,15 +10,34 @@ import { getActiveAccountIdFromPath } from "../utils/common.js";
 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 getActiveAccountIdFromPath(appId);
+            return getStoredActiveAccountId(appId);
         },
-        switchAccount(accountId, subPath = "") {
+        switchAccount(accountId) {
+            setStoredActiveAccountId(appId, accountId);
             if (typeof window === "undefined")
                 return;
-            const clean = subPath.replace(/^\/+/, "");
-            window.location.assign(`/${accountId}${clean ? `/${clean}` : "/"}`);
+            window.location.reload();
+        },
+        clearActiveAccount() {
+            setStoredActiveAccountId(appId, null);
         },
         async listMine() {
             return axios.get(`${base}/me`);
@@ -30,7 +49,8 @@ export function createAccountsModule(axios, appId) {
             return axios.patch(`${base}/${accountId}`, params);
         },
         async listMembers(accountId) {
-            return axios.get(`${base}/${accountId}/members`);
+            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 });
@@ -51,10 +71,35 @@ export function createAccountsModule(axios, appId) {
         },
         billing: {
             async listPlans(accountId) {
-                return axios.get(`${base}/${accountId}/billing/plans`);
+                const id = await resolveAccountId(accountId);
+                return axios.get(`${base}/${id}/billing/plans`);
+            },
+            async getSubscription(accountId) {
+                var _a, _b, _c, _d, _e, _f;
+                // /me is needed for the account's plan_id/billing_status, and also
+                // resolves the active account id — fetch it once and reuse it.
+                const mine = await axios.get(`${base}/me`);
+                const id = (_b = (_a = accountId !== null && accountId !== void 0 ? accountId : getStoredActiveAccountId(appId)) !== null && _a !== void 0 ? _a : mine.active_account_id) !== null && _b !== void 0 ? _b : undefined;
+                if (!id) {
+                    throw new Error("No active account: pass an accountId, or have the user select or create an account first.");
+                }
+                const plans = await axios.get(`${base}/${id}/billing/plans`);
+                const account = (_c = mine.accounts.find((a) => a.id === id)) !== null && _c !== void 0 ? _c : null;
+                const planId = (_d = account === null || account === void 0 ? void 0 : account.plan_id) !== null && _d !== void 0 ? _d : null;
+                return {
+                    account_id: id,
+                    plan_id: planId,
+                    billing_status: (_e = account === null || account === void 0 ? void 0 : account.billing_status) !== null && _e !== void 0 ? _e : "none",
+                    plan: planId ? (_f = plans.find((p) => p.id === planId)) !== null && _f !== void 0 ? _f : null : null,
+                };
             },
-            async startCheckout(accountId, params) {
-                return axios.post(`${base}/${accountId}/billing/checkout`, params);
+            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

@@ -4,8 +4,8 @@
  * 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).
+ * 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";
@@ -55,21 +55,38 @@ 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 resolved plan (matched from the account's available plans), or `null`. */
+    plan: AccountPlan | 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 the current URL path (or `undefined`). */
+    /** The active account id, read from stored client state (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.
+     * 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.
-     * @param subPath - Optional in-account route to land on (defaults to the root).
      */
-    switchAccount(accountId: string, subPath?: string): void;
+    switchAccount(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>;
     /** Create a new account; the current user becomes its owner. */
@@ -82,8 +99,11 @@ export interface AccountsModule {
         name?: string;
         data?: Record<string, unknown>;
     }): Promise<Account>;
-    /** List an account's members (any active member). */
-    listMembers(accountId: string): Promise<AccountMembership[]>;
+    /**
+     * 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. */
@@ -100,13 +120,21 @@ export interface AccountsModule {
     }>;
     /** 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>;
+        /**
+         * 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

@@ -4,7 +4,7 @@
  * 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).
+ * 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/utils/axios-client.js

@@ -1,5 +1,5 @@
 import axios from "axios";
-import { getActiveAccountIdFromPath, isInIFrame } from "./common.js";
+import { getStoredActiveAccountId, isInIFrame } from "./common.js";
 import { v4 as uuidv4 } from "uuid";
 /**
  * Custom error class for Base44 SDK errors.
@@ -131,13 +131,13 @@ export function createAxiosClient({ baseURL, headers = {}, token, appId, interce
     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);
+            // 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);
             }

package/dist/utils/common.d.ts

@@ -1,12 +1,19 @@
 export declare const isNode: boolean;
 export declare const isInIFrame: boolean;
 /**
- * The active account id from the URL, or undefined.
+ * The active account id from stored client state, 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.
+ * 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 getActiveAccountIdFromPath(appId?: string): string | undefined;
+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,24 +1,52 @@
 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.
+// 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 the URL, or undefined.
+ * The active account id from stored client state, 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.
+ * 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 getActiveAccountIdFromPath(appId) {
+export function getStoredActiveAccountId(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;
+    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) +

package/package.json

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