openxiangda 1.0.37 → 1.0.38

package/openxiangda-skills/references/pages/page-sdk.md

@@ -11,6 +11,8 @@ Guidelines:
 - Use `sdk.connector.invoke`, `sdk.connector.call("connector.api")`, or `sdk.connector.download` for external services. The SDK calls the platform runtime connector endpoint; it must not call third-party domains directly.
 - Use `sdk.notification.sendByType` and `batchSendByType` for reusable business messages. Custom notification types must be declared in `src/resources/notifications/` and published with `openxiangda resource publish`.
 - For the current user's department hierarchy, use `sdk.department.getCurrentUserParentDepartments()`; do not hardcode `GET /department/:id/parentDepartments` in page code.
+- Use `sdk.auth.logoutAndRedirect({ loginUrl })` for user logout when the page should return after login. It calls the platform logout endpoint, appends the current page URL as `callback`, and redirects to the login URL. Use `sdk.auth.logout()` only when the page wants to handle redirect itself.
+- Use `sdk.role.getMyRoles()`, `sdk.role.getCurrentRole()`, and `sdk.role.switchAppRole()` for current-user app role switching. Pass `roleId: ""` to switch back to all app roles.
 - Keep API calls behind small local functions so generated UI stays testable.
 - Treat user context and tenant context as runtime-provided values.
 
@@ -56,3 +58,33 @@ const response = await sdk.dataSource.run("tickets", {
 ```
 
 Data view filters and fields use output aliases such as `customerName`, not source references such as `customer.name`. If the page only needs one form, prefer `sdk.form.advancedSearch`. If the page only needs a simple one-form dropdown, prefer linkedForm options.
+
+Logout and current-user role switching:
+
+```ts
+await sdk.auth.logoutAndRedirect({
+  loginUrl: "/login",
+})
+
+await sdk.auth.logoutAndRedirect({
+  loginUrl: "/login",
+  callbackParamName: "redirect",
+})
+
+await sdk.auth.logout()
+
+const roles = await sdk.role.getMyRoles({ scope: "app" })
+const currentRole = await sdk.role.getCurrentRole({ scope: "app" })
+
+await sdk.role.switchAppRole({
+  roleId: roles.result?.[0]?.id || "",
+})
+
+await sdk.role.switchAppRole({
+  roleId: "",
+})
+
+await sdk.role.switchPlatformRole({
+  roleId: "platform-admin",
+})
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openxiangda",
-  "version": "1.0.37",
+  "version": "1.0.38",
   "description": "OpenXiangda CLI, workspace build tools, runtime SDK, and form components.",
   "private": false,
   "bin": {

package/packages/sdk/dist/runtime/index.cjs

@@ -361,6 +361,99 @@ var withDefaultAppType = (context, params) => {
   }
   return params;
 };
+var AUTH_LOGIN_URL_ENV_KEYS = [
+  "loginUrl",
+  "authLoginUrl",
+  "bathAuthUrl",
+  "REACT_APP_VITE_BATH_AUTH_URL",
+  "VITE_BATH_AUTH_URL",
+  "BATH_AUTH_URL"
+];
+var normalizeOptionalString = (value) => {
+  const text = typeof value === "string" ? value.trim() : "";
+  return text || void 0;
+};
+var getCurrentHref = () => {
+  if (typeof window === "undefined") {
+    return "";
+  }
+  return window.location?.href || "";
+};
+var resolveAuthLoginUrl = (context, options) => {
+  const explicitLoginUrl = normalizeOptionalString(options.loginUrl);
+  if (explicitLoginUrl) {
+    return explicitLoginUrl;
+  }
+  for (const key of AUTH_LOGIN_URL_ENV_KEYS) {
+    const loginUrl = normalizeOptionalString(context.env?.[key]);
+    if (loginUrl) {
+      return loginUrl;
+    }
+  }
+  return void 0;
+};
+var buildAuthRedirectUrl = (loginUrl, callbackUrl, callbackParamName) => {
+  const paramName = normalizeOptionalString(callbackParamName) || "callback";
+  const normalizedCallbackUrl = normalizeOptionalString(callbackUrl);
+  if (!normalizedCallbackUrl) {
+    return loginUrl;
+  }
+  const baseHref = getCurrentHref() || "http://localhost/";
+  const isAbsoluteUrl = /^[a-z][a-z\d+.-]*:/i.test(loginUrl);
+  const isProtocolRelativeUrl = loginUrl.startsWith("//");
+  const isRootRelativeUrl = loginUrl.startsWith("/");
+  try {
+    const url = new URL(loginUrl, baseHref);
+    url.searchParams.set(paramName, normalizedCallbackUrl);
+    if (isAbsoluteUrl || isProtocolRelativeUrl) {
+      return url.toString();
+    }
+    const path = `${url.pathname}${url.search}${url.hash}`;
+    return isRootRelativeUrl ? path : path.replace(/^\//, "");
+  } catch {
+    const hashIndex = loginUrl.indexOf("#");
+    const pathAndQuery = hashIndex >= 0 ? loginUrl.slice(0, hashIndex) : loginUrl;
+    const hash = hashIndex >= 0 ? loginUrl.slice(hashIndex) : "";
+    const separator = pathAndQuery.includes("?") ? "&" : "?";
+    return `${pathAndQuery}${separator}${encodeURIComponent(
+      paramName
+    )}=${encodeURIComponent(normalizedCallbackUrl)}${hash}`;
+  }
+};
+var performRedirect = (url, options) => {
+  if (options.redirect) {
+    options.redirect(url);
+    return;
+  }
+  if (typeof window === "undefined" || !window.location) {
+    return;
+  }
+  if (options.replace && typeof window.location.replace === "function") {
+    window.location.replace(url);
+    return;
+  }
+  window.location.href = url;
+};
+var reloadCurrentPage = () => {
+  if (typeof window === "undefined" || !window.location || typeof window.location.reload !== "function") {
+    return;
+  }
+  window.location.reload();
+};
+var redirectAfterLogout = (context, options) => {
+  const loginUrl = resolveAuthLoginUrl(context, options);
+  const callbackUrl = normalizeOptionalString(options.callbackUrl) || getCurrentHref();
+  if (loginUrl) {
+    performRedirect(
+      buildAuthRedirectUrl(loginUrl, callbackUrl, options.callbackParamName),
+      options
+    );
+    return;
+  }
+  if (options.fallback !== "none") {
+    reloadCurrentPage();
+  }
+};
 var createPageSdk = (context) => {
   const request = async (options) => {
     const payload = {
@@ -401,6 +494,26 @@ var createPageSdk = (context) => {
       throw toSdkError(error, payload);
     }
   };
+  const logout = () => request({
+    path: "/api/auth/logout",
+    method: "post"
+  });
+  const auth = {
+    logout,
+    logoutAndRedirect: async (options = {}) => {
+      try {
+        const response = await logout();
+        redirectAfterLogout(context, options);
+        return response;
+      } catch (error) {
+        if (options.continueOnLogoutError === false) {
+          throw error;
+        }
+        redirectAfterLogout(context, options);
+        return null;
+      }
+    }
+  };
   const connector = {
     invoke: (params) => request({
       path: buildAppPath(
@@ -1158,6 +1271,7 @@ var createPageSdk = (context) => {
       request,
       download
     },
+    auth,
     connector,
     form,
     user,