openxiangda 1.0.62 → 1.0.63

package/package.json

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

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

@@ -856,6 +856,7 @@ __export(runtime_exports, {
   usePageRoute: () => usePageRoute,
   usePageSdk: () => usePageSdk,
   usePermission: () => usePermission,
+  useRuntimeAuth: () => useRuntimeAuth,
   useRuntimeBootstrap: () => useRuntimeBootstrap
 });
 module.exports = __toCommonJS(runtime_exports);
@@ -3328,6 +3329,16 @@ var createBoundFetch = (fetchImpl) => {
 
 // packages/sdk/src/runtime/react/openxiangdaProvider.tsx
 var import_jsx_runtime3 = require("react/jsx-runtime");
+var RuntimeHttpError = class extends Error {
+  constructor(snapshot) {
+    super(snapshot.message);
+    this.name = "RuntimeHttpError";
+    this.type = snapshot.type;
+    this.status = snapshot.status;
+    this.code = snapshot.code;
+    this.payload = snapshot.payload;
+  }
+};
 var OpenXiangdaRuntimeContext = (0, import_react7.createContext)(null);
 var OpenXiangdaProvider = ({
   appType,
@@ -3350,7 +3361,10 @@ var OpenXiangdaProvider = ({
       setState({
         data: null,
         loading: false,
-        error: new Error("appType \u4E0D\u80FD\u4E3A\u7A7A")
+        error: createRuntimeError({
+          message: "appType \u4E0D\u80FD\u4E3A\u7A7A",
+          type: "unknown"
+        })
       });
       return;
     }
@@ -3368,9 +3382,13 @@ var OpenXiangdaProvider = ({
           headers: { accept: "application/json" }
         }
       );
-      const payload = await response.json();
+      const payload = await readJsonPayload(response);
       if (!response.ok || payload?.code >= 400) {
-        throw new Error(payload?.message || `Runtime bootstrap failed: ${response.status}`);
+        throw createRuntimeHttpError(
+          response,
+          payload,
+          payload?.message || `Runtime bootstrap failed: ${response.status}`
+        );
       }
       setState({
         data: payload?.data || null,
@@ -3381,7 +3399,7 @@ var OpenXiangdaProvider = ({
       setState({
         data: null,
         loading: false,
-        error: error instanceof Error ? error : new Error(String(error))
+        error: normalizeRuntimeError(error)
       });
     }
   }, [resolvedAppType, resolvedFetch, servicePrefix]);
@@ -3437,6 +3455,23 @@ var useCanAccessRoute = (input) => {
         setState((prev) => ({ ...prev, loading: runtime.loading }));
         return;
       }
+      if (runtime.error && !runtime.data) {
+        const snapshot = toRuntimeErrorSnapshot(runtime.error);
+        setState({
+          data: {
+            appType: runtime.appType,
+            canAccess: false,
+            status: snapshot.status,
+            code: snapshot.code,
+            message: snapshot.message,
+            errorType: snapshot.type,
+            payload: snapshot.payload
+          },
+          loading: false,
+          error: runtime.error
+        });
+        return;
+      }
       if (permissions?.hasFullAccess) {
         setState({
           data: { appType: runtime.appType, canAccess: true, permissions },
@@ -3464,15 +3499,33 @@ var useCanAccessRoute = (input) => {
             body: JSON.stringify(input)
           }
         );
-        const payload = await response.json();
+        const payload = await readJsonPayload(response);
+        const code = payload?.code ?? response.status;
+        const canAccess = Boolean(payload?.data?.canAccess);
+        const errorType = canAccess ? void 0 : classifyRuntimeError(response.status, code);
+        const data = {
+          ...payload?.data || {
+            appType: runtime.appType,
+            canAccess: false
+          },
+          appType: payload?.data?.appType || runtime.appType,
+          canAccess,
+          status: response.status,
+          code,
+          message: payload?.message,
+          errorType,
+          payload
+        };
         if (!disposed) {
+          const shouldTreatAsError = !response.ok || typeof code === "number" && code >= 500;
           setState({
-            data: payload?.data || {
-              appType: runtime.appType,
-              canAccess: false
-            },
+            data,
             loading: false,
-            error: response.ok && payload?.code < 500 ? null : new Error(payload?.message || `Route check failed: ${response.status}`)
+            error: shouldTreatAsError ? createRuntimeHttpError(
+              response,
+              payload,
+              payload?.message || `Route check failed: ${response.status}`
+            ) : null
           });
         }
       } catch (error) {
@@ -3480,7 +3533,7 @@ var useCanAccessRoute = (input) => {
           setState({
             data: null,
             loading: false,
-            error: error instanceof Error ? error : new Error(String(error))
+            error: normalizeRuntimeError(error)
           });
         }
       }
@@ -3512,16 +3565,226 @@ var PermissionBoundary = ({
   menuCode,
   path
 }) => {
+  const runtime = useOpenXiangda();
   const access = useCanAccessRoute({ routeCode, menuCode, path });
-  if (access.loading) return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children: loadingFallback });
-  if (!access.canAccess) return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children: fallback });
+  const fallbackState = createPermissionFallbackState(access, runtime);
+  if (access.loading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children: renderBoundaryFallback(loadingFallback, fallbackState) });
+  }
+  if (!access.canAccess) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children: renderBoundaryFallback(fallback, fallbackState) });
+  }
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children });
 };
+var useRuntimeAuth = () => {
+  const runtime = useOpenXiangda();
+  const resolveLoginUrl = (0, import_react7.useCallback)(
+    async (options = {}) => {
+      const redirectUri = options.redirectUri || getCurrentHref2();
+      const domain = options.domain || getCurrentHostname();
+      const appTenantId = getRecordString(runtime.data?.app, "tenantId");
+      try {
+        const statusUrl = withQuery(
+          buildServiceUrl(runtime.servicePrefix, "/api/sso/status"),
+          { domain }
+        );
+        const statusResponse = await runtime.fetchImpl(statusUrl, {
+          credentials: "include",
+          headers: { accept: "application/json" }
+        });
+        const statusPayload = await readJsonPayload(statusResponse);
+        const sso = statusPayload?.data || {};
+        const enabled = Boolean(sso.enabled);
+        const shouldUseSso = Boolean(
+          enabled && (sso.forceLogin ?? sso.autoRedirect ?? true)
+        );
+        if (shouldUseSso) {
+          const loginUrlResponse = await runtime.fetchImpl(
+            withQuery(buildServiceUrl(runtime.servicePrefix, "/api/sso/login-url"), {
+              domain,
+              redirectUri,
+              ...sso.tenantId || appTenantId ? { tenantId: String(sso.tenantId || appTenantId) } : {},
+              ...sso.protocol ? { protocol: String(sso.protocol) } : {}
+            }),
+            {
+              credentials: "include",
+              headers: { accept: "application/json" }
+            }
+          );
+          const loginUrlPayload = await readJsonPayload(loginUrlResponse);
+          const loginUrl = loginUrlPayload?.data?.loginUrl || loginUrlPayload?.data?.url || loginUrlPayload?.loginUrl || loginUrlPayload?.url;
+          if (loginUrl) return String(loginUrl);
+        }
+      } catch {
+      }
+      const configuredLoginUrl = options.loginUrl || getRuntimeEnv("OPENXIANGDA_LOGIN_URL") || getRuntimeEnv("VITE_OPENXIANGDA_LOGIN_URL") || getRuntimeEnv("APP_LOGIN_URL") || getRuntimeEnv("VITE_APP_LOGIN_URL") || getRuntimeEnv("VITE_BATH_AUTH_URL") || getRuntimeEnv("BATH_AUTH_URL");
+      if (configuredLoginUrl) {
+        return attachCallback(configuredLoginUrl, redirectUri);
+      }
+      return attachCallback("/login", redirectUri);
+    },
+    [runtime.data?.app, runtime.fetchImpl, runtime.servicePrefix]
+  );
+  const redirectToLogin = (0, import_react7.useCallback)(
+    async (options = {}) => {
+      const loginUrl = await resolveLoginUrl(options);
+      if (typeof window !== "undefined") {
+        if (options.replace === false) {
+          window.location.assign(loginUrl);
+        } else {
+          window.location.replace(loginUrl);
+        }
+      }
+      return loginUrl;
+    },
+    [resolveLoginUrl]
+  );
+  const logout = (0, import_react7.useCallback)(async () => {
+    const response = await runtime.fetchImpl(
+      buildServiceUrl(runtime.servicePrefix, "/api/auth/logout"),
+      {
+        method: "POST",
+        credentials: "include",
+        headers: { accept: "application/json" }
+      }
+    );
+    const payload = await readJsonPayload(response);
+    if (!response.ok || payload?.code >= 400) {
+      throw createRuntimeHttpError(
+        response,
+        payload,
+        payload?.message || `Logout failed: ${response.status}`
+      );
+    }
+    return payload;
+  }, [runtime.fetchImpl, runtime.servicePrefix]);
+  const logoutAndRedirect = (0, import_react7.useCallback)(
+    async (options = {}) => {
+      try {
+        await logout();
+      } catch (error) {
+        if (options.continueOnError === false) throw error;
+      }
+      return redirectToLogin(options);
+    },
+    [logout, redirectToLogin]
+  );
+  return {
+    logout,
+    logoutAndRedirect,
+    redirectToLogin,
+    resolveLoginUrl
+  };
+};
 var buildServiceUrl = (servicePrefix, path) => {
   const prefix2 = servicePrefix.endsWith("/") ? servicePrefix.slice(0, -1) : servicePrefix;
   const suffix = path.startsWith("/") ? path : `/${path}`;
   return `${prefix2}${suffix}`;
 };
+var readJsonPayload = async (response) => {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+};
+var createRuntimeHttpError = (response, payload, fallbackMessage) => createRuntimeError({
+  type: classifyRuntimeError(
+    response.status,
+    getRecordValue(payload, "code")
+  ),
+  status: response.status,
+  code: getRecordValue(payload, "code"),
+  message: getRecordValue(payload, "message") || fallbackMessage,
+  payload
+});
+var createRuntimeError = (snapshot) => new RuntimeHttpError({
+  ...snapshot,
+  type: snapshot.type || "unknown",
+  message: snapshot.message || "Runtime request failed"
+});
+var normalizeRuntimeError = (error) => {
+  if (error instanceof RuntimeHttpError) return error;
+  if (error instanceof Error) {
+    const runtimeError = error;
+    runtimeError.type = runtimeError.type || classifyRuntimeError(runtimeError.status, runtimeError.code);
+    return runtimeError;
+  }
+  return createRuntimeError({
+    type: "unknown",
+    message: String(error)
+  });
+};
+var toRuntimeErrorSnapshot = (error) => ({
+  type: error.type || classifyRuntimeError(error.status, error.code),
+  status: error.status,
+  code: error.code,
+  message: error.message || "Runtime request failed",
+  payload: error.payload
+});
+var classifyRuntimeError = (status, code) => {
+  const normalizedCode = typeof code === "string" ? Number(code) : code;
+  if (status === 401 || normalizedCode === 401) return "unauthenticated";
+  if (status === 403 || normalizedCode === 403) return "forbidden";
+  if (!status && !normalizedCode) return "network";
+  return "unknown";
+};
+var createPermissionFallbackState = (access, runtime) => {
+  const error = access.error || runtime.error;
+  const accessData = access.data;
+  const errorType = accessData?.errorType || error?.type || (!access.canAccess ? "forbidden" : "unknown");
+  return {
+    access,
+    runtime,
+    error,
+    errorType,
+    status: accessData?.status || error?.status,
+    code: accessData?.code || error?.code,
+    message: accessData?.message || error?.message || (errorType === "unauthenticated" ? "\u5F53\u524D\u8D26\u53F7\u5C1A\u672A\u767B\u5F55" : "\u5F53\u524D\u8D26\u53F7\u6CA1\u6709\u8BBF\u95EE\u6743\u9650")
+  };
+};
+var renderBoundaryFallback = (fallback, state) => typeof fallback === "function" ? fallback(state) : fallback;
+var withQuery = (url2, params) => {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === "") return;
+    query.set(key, String(value));
+  });
+  const serialized = query.toString();
+  if (!serialized) return url2;
+  return `${url2}${url2.includes("?") ? "&" : "?"}${serialized}`;
+};
+var attachCallback = (loginUrl, callback) => {
+  if (!callback) return loginUrl;
+  try {
+    const base = typeof window !== "undefined" ? window.location.origin : "http://localhost";
+    const parsed = new URL(loginUrl, base);
+    if (!parsed.searchParams.has("callback") && !parsed.searchParams.has("redirectUri")) {
+      parsed.searchParams.set("callback", callback);
+    }
+    if (loginUrl.startsWith("http://") || loginUrl.startsWith("https://")) {
+      return parsed.toString();
+    }
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    const separator = loginUrl.includes("?") ? "&" : "?";
+    return `${loginUrl}${separator}callback=${encodeURIComponent(callback)}`;
+  }
+};
+var getCurrentHref2 = () => typeof window === "undefined" ? "" : window.location.href;
+var getCurrentHostname = () => typeof window === "undefined" ? "" : window.location.hostname;
+var getRuntimeEnv = (key) => {
+  const env = typeof process !== "undefined" ? process.env : void 0;
+  return env?.[key];
+};
+var getRecordValue = (value, key) => {
+  if (!value || typeof value !== "object") return void 0;
+  return value[key];
+};
+var getRecordString = (value, key) => {
+  const result = getRecordValue(value, key);
+  return typeof result === "string" ? result : void 0;
+};
 var resolveAppTypeFromLocation = () => {
   if (typeof window === "undefined") return "";
   const segments = window.location.pathname.split("/").filter(Boolean);