@crimson-education/sdk 0.3.7 → 0.3.9

package/dist/core/account.d.ts

@@ -1,5 +1,5 @@
 import type { CrimsonClient } from "./client";
-import type { CurrentUserRoles, StudentSummary, UserProfile } from "./types";
+import type { CurrentUserRoles, StudentSummary, UserProfile, LinkedTenantsResponse } from "./types";
 export declare class AccountApi {
     private client;
     constructor(client: CrimsonClient);
@@ -37,4 +37,10 @@ export declare class AccountApi {
      * @returns User profile information
      */
     getMyProfile(): Promise<UserProfile>;
+    /**
+     * Get the list of tenants linked to the current user
+     *
+     * @returns List of linked tenants and current tenant info
+     */
+    getLinkedTenants(): Promise<LinkedTenantsResponse>;
 }

package/dist/core/account.js

@@ -62,5 +62,15 @@ class AccountApi {
             return this.client.fetch("/api/v1/account/me/profile");
         });
     }
+    /**
+     * Get the list of tenants linked to the current user
+     *
+     * @returns List of linked tenants and current tenant info
+     */
+    getLinkedTenants() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.fetch("/api/v1/account/linked-tenants");
+        });
+    }
 }
 exports.AccountApi = AccountApi;

package/dist/core/client.d.ts

@@ -19,12 +19,19 @@ export declare class CrimsonClient {
     private appName;
     private appTenant;
     private oauthAdapter?;
+    private tenantDomain?;
+    private isResolvingDomain;
+    private tenantDomainPromise?;
     constructor(config: CrimsonClientConfig);
     /**
      * Initialize the client (required for OAuth mode)
      * Call this after creating the client to load stored tokens
      */
     initialize(): Promise<void>;
+    /**
+     * Resolve the x-tenant-domain dynamically
+     */
+    resolveTenantDomain(): Promise<void>;
     /**
      * Get the OAuth adapter (only available in OAuth mode)
      */

package/dist/core/client.js

@@ -45,6 +45,7 @@ function isOAuthConfig(config) {
 class CrimsonClient {
     constructor(config) {
         this.config = config;
+        this.isResolvingDomain = false;
         this.missions = new missions_1.MissionsApi(this);
         this.tasks = new tasks_1.TasksApi(this);
         this.roadmap = new roadmap_1.RoadmapApi(this);
@@ -91,6 +92,55 @@ class CrimsonClient {
             }
         });
     }
+    /**
+     * Resolve the x-tenant-domain dynamically
+     */
+    resolveTenantDomain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.tenantDomain)
+                return;
+            if (!this.tenantDomainPromise) {
+                this.isResolvingDomain = true;
+                this.tenantDomainPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    try {
+                        const token = yield this.getToken();
+                        if (!token) {
+                            // Silently return without error if called early;
+                            // it will be lazily retried in fetch() or when token is received.
+                            this.tenantDomainPromise = undefined;
+                            return;
+                        }
+                        // A newer version of profile will return domain
+                        const profile = yield this.account.getMyProfile();
+                        if ((_a = profile.tenant) === null || _a === void 0 ? void 0 : _a.domain) {
+                            this.tenantDomain = profile.tenant.domain;
+                        }
+                        else {
+                            // Use getLinkedtenants as a safe fallback when getMyProfile does not return a domain.
+                            // Can be removed later.
+                            const linkedRes = yield this.account.getLinkedTenants();
+                            if (linkedRes.linkedTenants && linkedRes.linkedTenants.length > 0) {
+                                // find domain.tenantId equals to currentTenantId
+                                const domain = (_b = linkedRes.linkedTenants.find(t => t.tenantId === linkedRes.currentTenantId)) === null || _b === void 0 ? void 0 : _b.tenantDomain;
+                                if (domain) {
+                                    this.tenantDomain = domain;
+                                }
+                            }
+                        }
+                    }
+                    catch (err) {
+                        console.warn('[CrimsonSDK] Failed to resolve tenant domain:', err);
+                        this.tenantDomainPromise = undefined;
+                    }
+                    finally {
+                        this.isResolvingDomain = false;
+                    }
+                }))();
+            }
+            return this.tenantDomainPromise;
+        });
+    }
     /**
      * Get the OAuth adapter (only available in OAuth mode)
      */
@@ -192,6 +242,10 @@ class CrimsonClient {
     }
     fetch(path_1) {
         return __awaiter(this, arguments, void 0, function* (path, options = {}) {
+            // If it's a roadmap endpoint, wait for tenant domain to be resolved first
+            if (path.includes("/roadmap")) {
+                yield this.resolveTenantDomain();
+            }
             const token = yield this.getToken();
             if (!token) {
                 throw new Error("No authentication token available");
@@ -207,6 +261,10 @@ class CrimsonClient {
             if (this.appTenant) {
                 headers["X-App-Tenant"] = this.appTenant;
             }
+            console.log(`tenantDomain = ${this.tenantDomain}`);
+            if (this.tenantDomain) {
+                headers["x-tenant-domain"] = this.tenantDomain;
+            }
             const url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
             const response = yield fetch(url, Object.assign(Object.assign({}, options), { headers }));
             if (!response.ok) {

package/dist/core/types.d.ts

@@ -494,8 +494,22 @@ export interface UserProfile {
     tenant: {
         id: string;
         name: string;
+        domain?: string;
     };
 }
+export interface LinkedTenant {
+    tenantId: string;
+    tenantName: string;
+    tenantDomain: string | null;
+    tenantLevel: number;
+    isCurrent: boolean;
+    userEmail: string;
+}
+export interface LinkedTenantsResponse {
+    currentUserId: string;
+    currentTenantId: string;
+    linkedTenants: LinkedTenant[];
+}
 /**
  * Prefilled field with value and source information
  */

package/dist/react/provider.js

@@ -36,8 +36,18 @@ function CrimsonProvider({ children, apiUrl, allowedParentOrigins, queryClient:
     }), [apiUrl, clientId, appName, appTenant]);
     (0, react_1.useEffect)(() => {
         const origins = allowedParentOrigins || (0, iframe_1.getDefaultAllowedOrigins)();
-        const cleanup = (0, iframe_1.setupIframeListener)(origins);
-        return cleanup;
-    }, [allowedParentOrigins]);
+        const cleanupIframe = (0, iframe_1.setupIframeListener)(origins);
+        // Eagerly resolve tenant domain as soon as token becomes available from iframe
+        const cleanupAuth = (0, iframe_1.subscribeToAuthState)(() => {
+            const state = (0, iframe_1.getAuthState)();
+            if (state.token) {
+                client.resolveTenantDomain().catch(() => { });
+            }
+        });
+        return () => {
+            cleanupIframe();
+            cleanupAuth();
+        };
+    }, [allowedParentOrigins, client]);
     return ((0, jsx_runtime_1.jsx)(CrimsonContext.Provider, { value: { client }, children: (0, jsx_runtime_1.jsx)(react_query_1.QueryClientProvider, { client: queryClient, children: children }) }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crimson-education/sdk",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Crimson SDK for accessing Crimson App APIs",
   "main": "dist/index.js",
   "module": "dist/index.js",