@mu-cabin/opms-permission 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# @mu-cabin/opms-permission
+
+## 简介
+
+`@mu-cabin/opms-permission` 是一个用于 OPMS 权限与认证管理的前端 SDK，支持资源、菜单、组织、用户信息的统一获取与本地缓存，适用于需要接入 OPMS 权限体系的前端项目。
+
+## 安装
+
+```bash
+pnpm add @mu-cabin/opms-permission
+# 或
+yarn add @mu-cabin/opms-permission
+# 或
+npm install @mu-cabin/opms-permission
+```
+
+## 主要功能
+- SSO 单点登录/登出跳转
+- 用户信息获取与本地缓存
+- 资源、菜单、控件权限获取与处理
+- 组织树、公司信息查询
+- 本地存储自动过期管理
+
+## 快速开始
+
+```ts
+import { OpmsPermission, jumpToSSOLogin, jumpToSSOLogout } from '@mu-cabin/opms-permission';
+
+const permission = new OpmsPermission({
+  systemId: 1001, // 系统ID
+  baseUrl: 'https://your-api-domain/opms', // OPMS后端接口地址
+  ssoBaseUrl: 'https://your-sso-domain', // SSO登录地址
+});
+
+// 登录（需URL带有code参数）
+await permission.login();
+
+// 获取用户信息
+const userInfo = await permission.getUserInfo();
+
+// 获取资源、菜单、控件权限
+const { resources, menuList, widgetMap } = await permission.getResources(userInfo.account);
+
+// 跳转到SSO登录
+jumpToSSOLogin({ baseUrl: 'https://your-sso-domain' });
+
+// 跳转到SSO登出
+jumpToSSOLogout({ baseUrl: 'https://your-sso-domain', redirectToUrl: window.location.origin });
+```
+
+## 主要API
+
+### 类：OpmsPermission
+
+| 方法 | 说明 |
+| ---- | ---- |
+| `login()` | SSO登录，获取并缓存token |
+| `logout()` | 登出并清除本地缓存 |
+| `getUserInfo()` | 获取当前用户信息 |
+| `getResources(uniAccount)` | 获取资源、菜单、控件权限 |
+| `queryOrgs()` | 获取组织树 |
+| `queryCompanies()` | 获取公司信息 |
+| `isLogin()` | 判断当前是否已登录 |
+| `getToken()` | 获取当前token |
+
+### SSO 工具方法
+- `jumpToSSOLogin({ baseUrl, redirectUrl?, clientId? })` 跳转到SSO登录页
+- `jumpToSSOLogout({ baseUrl, redirectToUrl, clientId? })` 跳转到SSO登出页
+
+## 类型说明
+
+- `Resource` 资源对象，包含资源ID、类型、路径、子节点等
+- `MenuItem` 菜单项对象，包含菜单路径、名称、子菜单等
+- `UserInfo` 用户信息对象，包含账号、姓名、工号、组织等
+- `UserOrganization` 用户组织信息
+
+## 常见问题
+
+1. **为什么获取不到资源/菜单？**
+   - 请确保已正确登录（URL带有code参数），并且接口地址、systemId 配置正确。
+2. **本地缓存多久失效？**
+   - 资源、菜单等默认缓存24小时，超时会自动重新拉取。
+3. **如何自定义SSO clientId？**
+   - `jumpToSSOLogin` 和 `jumpToSSOLogout` 方法均支持传入 `clientId` 参数。
+
+## License

package/dist/index.cjs

@@ -0,0 +1,529 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OpmsPermission: () => Permission,
+  jumpToSSOLogin: () => jumpToSSOLogin,
+  jumpToSSOLogout: () => jumpToSSOLogout
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/storage.ts
+var Storage = class {
+  setSystemId(systemId) {
+    this.systemId = systemId;
+  }
+  prefixKey(key) {
+    return this.systemId !== void 0 ? `systemId-${this.systemId}-${key}` : key;
+  }
+  /**
+   * Set an item in localStorage, with optional expiration in minutes
+   */
+  setItem(key, value, expireMinutes) {
+    const data = {
+      value,
+      expire: expireMinutes ? Date.now() + expireMinutes * 60 * 1e3 : null
+    };
+    localStorage.setItem(this.prefixKey(key), JSON.stringify(data));
+  }
+  /**
+   * Get an item from localStorage, returns undefined if expired or not found
+   */
+  getItem(key) {
+    const raw = localStorage.getItem(this.prefixKey(key));
+    if (!raw) return void 0;
+    try {
+      const data = JSON.parse(raw);
+      if (data.expire && Date.now() > data.expire) {
+        localStorage.removeItem(this.prefixKey(key));
+        return void 0;
+      }
+      return data.value;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Remove an item from localStorage
+   */
+  removeItem(key) {
+    localStorage.removeItem(this.prefixKey(key));
+  }
+};
+var storage = new Storage();
+
+// src/utils/dataHandler.ts
+function getCompletePath(item) {
+  const menuUrl = item.openIndicator === "INNER_COMPONENT" ? item.componentPath : item.defaultUrl;
+  return menuUrl ?? "";
+}
+function getMenuName(item) {
+  return item.resourceType !== "FOLDER" ? item.resourceName || "" : (item.showName ?? item.resourceName) || "";
+}
+function createResourceMap(items) {
+  const resourceMap = {};
+  const widgetMap = {};
+  function addToMap(items2) {
+    items2.forEach((item) => {
+      const newItem = { ...item };
+      if (newItem.defaultResourceType === "WIDGET") {
+        if (newItem.componentPath) widgetMap[newItem.componentPath] = newItem;
+      } else {
+        const path = getCompletePath(newItem);
+        if (path) {
+          resourceMap[path] = newItem;
+        }
+      }
+      if (newItem.children) {
+        addToMap(newItem.children);
+      }
+    });
+  }
+  addToMap(items);
+  return { resourceMap, widgetMap };
+}
+function isMenuItem(item) {
+  const resourceType = item.resourceType ?? item.defaultResourceType;
+  return resourceType !== "WIDGET";
+}
+function createMenuList(items) {
+  const menus = [];
+  const menuMap = {};
+  const filterMenus = (items2, container) => {
+    items2.forEach((item) => {
+      const icon = item.icon || item.defaultIcon;
+      const path = getCompletePath(item);
+      const name = getMenuName(item);
+      const newItem = {
+        icon,
+        path,
+        name,
+        children: [],
+        openIndicator: item.openIndicator,
+        resourceId: item.resourceId
+      };
+      menuMap[newItem.resourceId] = newItem;
+      if (isMenuItem(item)) {
+        container.push(newItem);
+      }
+      if (item.children) {
+        filterMenus(item.children, newItem.children);
+      }
+    });
+  };
+  filterMenus(items, menus);
+  return { menuList: menus, menuMap };
+}
+function iterateNestedArray(items, callback) {
+  function trevel(items2, parent) {
+    return items2.map((item) => {
+      const handledItem = callback(item, parent);
+      if (handledItem && handledItem.children) {
+        handledItem.children = trevel(handledItem.children, handledItem);
+      }
+      return handledItem;
+    }).filter((v) => v);
+  }
+  return trevel(items);
+}
+function findFirstEnableCode(data) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return null;
+  }
+  let queue = [...data];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (!node?.disabled) {
+      return node?.value || null;
+    }
+    if (Array.isArray(node.children) && node.children.length > 0) {
+      queue = queue.concat(node.children);
+    }
+  }
+  return null;
+}
+function findAllEnableTopLevelCodes(nodes) {
+  const codes = [];
+  function findEnabledNodes(nodes2) {
+    for (const node of nodes2) {
+      if (!node.disabled) {
+        codes.push(node.value);
+      } else if (node.children) {
+        findEnabledNodes(node.children);
+      }
+    }
+  }
+  findEnabledNodes(nodes);
+  return codes;
+}
+
+// src/api.ts
+var import_axios = __toESM(require("axios"));
+
+// src/config.ts
+var USER_INFO_KEY = "opms_user_info";
+var RESOURCE_KEY = "opms_resources";
+var TOKEN_KEY = "omps_authorization";
+var ORG_COMPANY_KEY = "opms_org_company";
+
+// src/api.ts
+var axiosClient = import_axios.default.create();
+axiosClient.interceptors.request.use((config) => {
+  const token = storage.getItem(TOKEN_KEY);
+  if (token) {
+    config.headers.Authorization = token;
+  }
+  return config;
+});
+axiosClient.interceptors.response.use(
+  (response) => {
+    const res = response.data;
+    const { code, msg } = res;
+    if (code !== 200) {
+      throw new Error(msg);
+    }
+    return res;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+async function login(baseUrl, authorizationCode) {
+  return await axiosClient.get(
+    `${baseUrl}/opmsDefaultAuth/oauthLogin`,
+    {
+      params: { authorizationCode }
+    }
+  );
+}
+async function logout(baseUrl) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultAuth/logout`
+  );
+}
+async function getUserInfo(baseUrl) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/userInfo`,
+    {}
+  );
+}
+async function queryResource(baseUrl, params) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/userResource`,
+    params
+  );
+}
+async function getUserOrgTree(baseUrl, params) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/orgTree`,
+    params
+  );
+}
+async function queryOrgCompanies(baseUrl, params) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/branches`,
+    params
+  );
+}
+
+// src/permission.ts
+var Permission = class {
+  constructor(options) {
+    this._userInfo = null;
+    this._orgTree = null;
+    this._orgCompany = null;
+    this.resources = [];
+    this.resourceMap = {};
+    this.widgetMap = {};
+    this.menuList = [];
+    this.menuMap = {};
+    this.baseUrl = options.baseUrl;
+    this.systemId = options.systemId;
+    storage.setSystemId(this.systemId);
+  }
+  /**
+   * Login using code from URL, save userInfo
+   */
+  async login() {
+    const url = new URL(window.location.href);
+    const code = url.searchParams.get("code");
+    if (!code) throw new Error("No code found in URL");
+    const { obj, success, msg } = await login(this.baseUrl, code);
+    if (!success) {
+      throw new Error(msg);
+    }
+    const { token } = obj;
+    url.searchParams.delete("code");
+    storage.setItem(TOKEN_KEY, token);
+    return token;
+  }
+  /**
+   * Logout and clear userInfo
+   */
+  async logout() {
+    await logout(this.baseUrl);
+    this.clear();
+  }
+  clear() {
+    this._userInfo = null;
+    this._orgTree = null;
+    this._orgCompany = null;
+    this.resources = [];
+    this.resourceMap = {};
+    this.widgetMap = {};
+    this.menuList = [];
+    this.menuMap = {};
+    storage.removeItem(RESOURCE_KEY);
+    storage.removeItem(TOKEN_KEY);
+    storage.removeItem(USER_INFO_KEY);
+    storage.removeItem(ORG_COMPANY_KEY);
+  }
+  async getUserInfo() {
+    const data = await getUserInfo(this.baseUrl);
+    const { obj, success, msg } = data;
+    if (!success) {
+      return Promise.reject(new Error(msg));
+    }
+    this._userInfo = obj;
+    return obj;
+  }
+  /**
+   * Get resources and process to menuList, menuMap, widgetMap (matches app store logic)
+   */
+  async getResources() {
+    const resourcesObj = storage.getItem(RESOURCE_KEY) || null;
+    if (resourcesObj) {
+      const { menuList: menuList2, menuMap: menuMap2 } = createMenuList(resourcesObj.resources);
+      return {
+        resources: resourcesObj.resources,
+        resourceMap: resourcesObj.resourceMap,
+        widgetMap: resourcesObj.widgetMap,
+        menuList: menuList2,
+        menuMap: menuMap2
+      };
+    }
+    const { obj, success, msg } = await queryResource(this.baseUrl, {
+      systemId: this.systemId
+    });
+    if (!success) {
+      return Promise.reject(new Error(msg));
+    }
+    const resources = obj;
+    const { resourceMap, widgetMap } = createResourceMap(resources);
+    const { menuList, menuMap } = createMenuList(resources);
+    this.resources = resources;
+    this.resourceMap = resourceMap;
+    this.widgetMap = widgetMap;
+    this.menuList = menuList;
+    this.menuMap = menuMap;
+    storage.setItem(
+      RESOURCE_KEY,
+      {
+        resources,
+        resourceMap,
+        widgetMap
+      },
+      60 * 24
+      // 24 hours
+    );
+    return {
+      resources,
+      resourceMap,
+      widgetMap,
+      menuList,
+      menuMap
+    };
+  }
+  /**
+   * Query and process organization tree
+   */
+  async queryOrgs() {
+    try {
+      const data = await getUserOrgTree(this.baseUrl, {
+        systemId: this.systemId,
+        name: "COS"
+      });
+      const { obj, success, msg } = data;
+      if (!success) {
+        return Promise.reject(new Error(msg));
+      }
+      const orgTree = obj;
+      const newTree = iterateNestedArray([orgTree], (item) => {
+        return {
+          label: item.orgShortName,
+          value: item.orgCode,
+          title: item.orgShortName,
+          key: item.orgCode,
+          nodeLevel: item.nodeLevel,
+          children: item.children,
+          disabled: !item.hasPermission,
+          orgType: item.orgType
+        };
+      })?.[0];
+      this._orgTree = newTree;
+      return newTree;
+    } catch (error) {
+      console.log(error);
+      return null;
+    }
+  }
+  async queryCompanies() {
+    try {
+      let orgCompanyList = storage.getItem(ORG_COMPANY_KEY);
+      if (!orgCompanyList) {
+        const { obj } = await queryOrgCompanies(this.baseUrl, { queryAllBranches: true });
+        orgCompanyList = obj;
+        storage.setItem(ORG_COMPANY_KEY, orgCompanyList);
+      }
+      this._orgCompany = orgCompanyList;
+    } catch (error) {
+      console.log(error);
+    }
+  }
+  isLogin() {
+    return !!storage.getItem(TOKEN_KEY);
+  }
+  getToken() {
+    return storage.getItem(TOKEN_KEY);
+  }
+  // --- Getters ---
+  get userInfo() {
+    if (!this._userInfo) {
+      this._userInfo = storage.getItem(USER_INFO_KEY);
+    }
+    if (!this._userInfo) return null;
+    const { account, name, ehrId, crewCode, crewId } = this._userInfo;
+    return { account, name, ehrId, crewCode, crewId };
+  }
+  get hasRootAuth() {
+    const orgs = this._userInfo?.organizations || [];
+    const first = orgs[0];
+    if (!first) return false;
+    return first.searchPath === "#1";
+  }
+  get userOrganizations() {
+    return this._userInfo?.userOrganizations || [];
+  }
+  get allCompanyOptions() {
+    const orgCompany = this._orgCompany;
+    if (!orgCompany) return [];
+    const list = orgCompany.map((v) => ({
+      label: v.orgName,
+      value: v.orgCode
+    }));
+    list.unshift({ label: "\u5168\u516C\u53F8", value: "EA" });
+    return list;
+  }
+  get companyOptions() {
+    const orgTree = this._orgTree;
+    if (!orgTree) return [];
+    const list = (orgTree.children || []).map(
+      ({ children, ...others }) => ({ ...others, disabled: false })
+    );
+    if (this.hasRootAuth) {
+      list.unshift({ ...orgTree, label: "\u5168\u516C\u53F8", children: [] });
+    }
+    return list;
+  }
+  get firstCompanyOrgCode() {
+    return this.companyOptions?.[0]?.value ?? "";
+  }
+  get unitOptions() {
+    const orgTree = this._orgTree;
+    if (!orgTree) return [];
+    return orgTree.disabled ? orgTree.children ?? [] : [orgTree];
+  }
+  get allUnitOptions() {
+    const orgTree = this._orgTree;
+    if (!orgTree) return [];
+    const newTree = iterateNestedArray(
+      [orgTree],
+      ({ disabled, ...other }) => ({ ...other })
+    )?.[0];
+    return newTree ? newTree.children ?? [] : [];
+  }
+  get firstUnitOrgCode() {
+    if (this.hasRootAuth) {
+      return this.companyOptions[1]?.value ?? "";
+    }
+    const orgTree = this._orgTree;
+    if (!orgTree) return "";
+    return findFirstEnableCode([orgTree]) ?? "";
+  }
+  get topLevelUnitOrgCodes() {
+    const orgTree = this._orgTree;
+    if (!orgTree) return [];
+    return findAllEnableTopLevelCodes(
+      Array.isArray(orgTree) ? orgTree : [orgTree]
+    );
+  }
+};
+
+// src/sso.ts
+function jumpToSSOLogin({
+  baseUrl,
+  redirectUrl,
+  clientId = "testSA19"
+}) {
+  const { location } = window;
+  const ssoUrl = new URL(`${baseUrl}/idp/oauth2/authorize`);
+  const defaultUrl = new URL(
+    location.origin + location.pathname + location.search
+  );
+  ssoUrl.searchParams.set("client_id", clientId);
+  ssoUrl.searchParams.set("response_type", "code");
+  ssoUrl.searchParams.set("redirect_uri", redirectUrl || defaultUrl.toString());
+  window.location.href = ssoUrl.toString();
+}
+function jumpToSSOLogout({
+  baseUrl,
+  redirectToUrl,
+  clientId = "testSA19"
+}) {
+  if (!baseUrl) {
+    throw new Error("baseUrl is required");
+  }
+  const { location } = window;
+  const ssoLoginUrl = `${baseUrl}/idp/oauth2/authorize?client_id=${clientId}&response_type=code&redirect_uri=${location.origin}/`;
+  const redirectUrl = encodeURIComponent(redirectToUrl || ssoLoginUrl);
+  const logoutUrl = new URL(`${baseUrl}/idp/profile/OAUTH2/Redirect/GLO`);
+  logoutUrl.searchParams.set("response_type", "code");
+  logoutUrl.searchParams.set("entityId", clientId);
+  logoutUrl.searchParams.set("redirectToLogin", "true");
+  logoutUrl.searchParams.set("redirctToUrl", redirectUrl);
+  window.location.href = logoutUrl.toString();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpmsPermission,
+  jumpToSSOLogin,
+  jumpToSSOLogout
+});