neo-cmp-cli 1.3.10 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neo-cmp-cli",
-  "version": "1.3.10",
+  "version": "1.5.1",
   "description": "前端脚手架：自定义组件开发工具，支持react 和 vue2.0技术栈。",
   "keywords": [
     "neo-cli",
@@ -41,10 +41,13 @@
     "url": "https://github.com/wibetter/neo-cmp-cli/issues"
   },
   "dependencies": {
+    "adm-zip": "^0.5.10",
     "akfun": "^5.1.12",
+    "axios": "^0.27.2",
     "chalk": "^4.0.0",
     "deepmerge": "^4.2.2",
     "figlet": "^1.2.0",
+    "form-data": "^4.0.0",
     "fs-extra": "^10.1.0",
     "inquirer": "^7.3.3",
     "ora": "^4.0.4",

package/src/cmpUtils/publishCmp.js

@@ -0,0 +1,221 @@
+const fs = require('fs');
+const path = require('path');
+const AdmZip = require('adm-zip');
+const _ = require('lodash');
+const { catchCurPackageJson, resolveToCurrentRoot } = require('../utils/pathUtils');
+const getConfigObj = require('../utils/getConfigObj');
+const ora = require('ora');
+const NeoService = require('../neo/neoService');
+
+// 获取当前项目的package文件
+const currentPackageJsonDir = catchCurPackageJson();
+const currentPackageJson = getConfigObj(currentPackageJsonDir);
+
+/**
+ * 将构建产物打包成 zip 文件
+ * @param {string} assetsRoot 构建产物的目录
+ * @returns {Promise<string>} zip 文件路径
+ */
+const createZipPackage = async (assetsRoot) => {
+  if (!fs.existsSync(assetsRoot)) {
+    throw new Error(`assetsRoot 不存在: ${assetsRoot}`);
+  }
+
+  const files = fs.readdirSync(assetsRoot);
+  const zip = new AdmZip();
+
+  files.forEach((file) => {
+    const filePath = path.join(assetsRoot, file);
+    const fileStat = fs.statSync(filePath);
+    if (fileStat.isFile()) {
+      // 只添加 .js 文件
+      if (file.endsWith('.js')) {
+        zip.addLocalFile(filePath);
+      }
+    }
+  });
+
+  const zipPath = path.join(assetsRoot, `${currentPackageJson.name}.zip`);
+  zip.writeZip(zipPath);
+  console.info(`已创建 zip 文件: ${zipPath}`);
+
+  return zipPath;
+};
+
+/**
+ * 获取技术栈标识
+ * 目的：兼容用户非标准写法
+ * 0: React, 1: vue2, 2: jQuery, 3: vue3
+ */
+export function getFramework(_framework) {
+  let defaultFramework = '0'; // 默认 React 技术栈
+  if (!_framework) {
+    return defaultFramework;
+  }
+  let curFramework = _framework.toLowerCase().trim();
+  switch (curFramework) {
+    case 'jquery':
+    case 'jq':
+      curFramework = '2';
+      break;
+    case 'vue2':
+    case 'vue 2':
+    case 'vue2.0':
+    case 'vue 2.0':
+      curFramework = '1';
+      break;
+    case 'vue':
+    case 'vue3':
+    case 'vue 3':
+    case 'vue3.0':
+    case 'vue 3.0':
+      curFramework = '3';
+      console.error(`${consoleTag} 暂不支持 vue3.0 技术栈。`);
+      break;
+    default:
+      curFramework = '0';
+  }
+  return curFramework;
+}
+
+/**
+ * 构建组件数据映射
+ * @param {string} assetsRoot 构建产物的目录
+ * @param {object} cmpInfo 自定义组件信息
+ * @returns {object} 自定义组件数据（含自定义组件模型信息）
+ */
+const buildComponentData = (assetsRoot, cmpInfo) => {
+  if (!cmpInfo || !cmpInfo.cmpType) {
+    console.error('自定义组件信息或组件名称不能为空');
+    return null;
+  }
+
+  const { cmpType } = cmpInfo;
+  
+  if (!assetsRoot || !fs.existsSync(assetsRoot)) {
+    console.error(`未找到自定义组件资源目录: ${assetsRoot}`);
+    return null;
+  }
+  const widgetName = _.kebabCase(cmpType);
+  const modelFile = path.join(assetsRoot, `${widgetName}Model.js`);
+  
+  let ModelClass = null;
+
+  try {
+    // 加载自定义组件模型资源文件
+    if (fs.existsSync(modelFile)) {
+      // 清除 require 缓存，确保每次都加载最新内容
+      const resolvedPath = require.resolve(modelFile);
+      if (require.cache[resolvedPath]) {
+        delete require.cache[resolvedPath];
+      }
+      const modelModule = require(modelFile);
+      // 获取导出的模型类（可能是 default 导出或命名导出）
+      ModelClass = modelModule.default || modelModule;
+      // 如果是命名导出，尝试查找类名（例如 EntityCardListModel）
+      if (typeof ModelClass !== 'function' && typeof modelModule === 'object') {
+        // 查找所有导出的类
+        const exportedClasses = Object.values(modelModule).filter(
+          (item) => typeof item === 'function'
+        );
+        if (exportedClasses.length > 0) {
+          ModelClass = exportedClasses[0];
+        }
+      }
+    }
+    // 如果资源文件不存在，报错
+    else {
+      console.error(`未找到自定义组件模型文件，请检查以下路径是否存在：`);
+      return null;
+    }
+
+    // 如果 ModelClass 是函数（类），则实例化
+    if (typeof ModelClass !== 'function') {
+      console.error(`模型文件 ${modelFile} 未导出有效的模型类`);
+      return null;
+    }
+
+    // 实例化模型类
+    const modelInstance = new ModelClass();
+
+    // 构建组件数据，合并模型实例的信息
+    const curCmpInfo = {
+      ...cmpInfo,
+      version: currentPackageJson.version || '1.0.0',
+      framework: currentPackageJson.framework ? getFramework(currentPackageJson.framework) : '0', // 0: React, 1: vue2, 2: jQuery, 3: vue3
+      // 从模型实例中提取并设置组件信息
+      label: modelInstance.label || cmpType,
+      description: modelInstance.description || '',
+      componentCategory: modelInstance.tags || [],
+      icon: modelInstance.iconSrc,
+      defaultProps: modelInstance.defaultComProps || {},
+      previewProps: modelInstance.previewComProps || {},
+      propsSchema: modelInstance.propsSchema || [],
+      events: modelInstance.events || [],
+      actions: modelInstance.actions || [],
+      // 如果模型实例中有其他属性，也可以添加
+      exposedToDesigner: modelInstance.exposedToDesigner !== undefined ? modelInstance.exposedToDesigner : true,
+      namespace: modelInstance.namespace || 'neo-cmp-cli',
+      enableDuplicate: modelInstance.enableDuplicate !== undefined ? modelInstance.enableDuplicate : true
+    };
+
+    return curCmpInfo;
+  } catch (error) {
+    console.error(`自定义组件模型文件解析失败 (${modelFile || '未知路径'}):`, error.message);
+    console.error(error.stack);
+    return null;
+  }
+};
+
+/**
+ * 发布组件到 NeoCRM
+ * @param {object} config 配置信息
+ * @param {string} assetsRoot 构建产物的目录
+ */
+const publishCmp = async (config, cmpType) => {
+  const {
+    authorization: credentials
+  } = config;
+
+  if (!credentials) {
+    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / publishCmpConfig / credentials）。');
+    return;
+  }
+
+  const spinner = ora('正在发布组件...').start();
+
+  try {
+    // 步骤 1: 初始化 NeoService
+    spinner.text = '发布自定义组件：初始化 NeoService...';
+    const neoService = new NeoService(config);
+
+    // 步骤 2: 上传构建后资源文件
+    spinner.text = '发布自定义组件：上传自定义组件构建产物到 OSS...';
+    const cmpInfo = await neoService.publish2oss(cmpType);
+
+    /*
+    // 步骤 3: 打包文件（打包单个自定义组件源码）
+    spinner.text = '发布自定义组件：打包文件（打包单个自定义组件源码）...';
+    const zipPath = await createZipPackage(assetsRoot);
+    */
+
+    // 步骤 4: 构建组件数据
+    spinner.text = '发布自定义组件：构建组件数据...';
+    const componentInfo = buildComponentData(config.assetsRoot, cmpInfo);
+    if (!componentInfo) {
+      throw new Error('构建组件数据失败，无法继续发布');
+    }
+
+    // 步骤 5: 保存组件信息
+    spinner.text = '发布自定义组件：保存组件信息...';
+    await neoService.updateCustomComponent(componentInfo);
+
+    spinner.succeed('自定义组件发布成功！\n', componentInfo);
+  } catch (error) {
+    spinner.fail(`自定义组件发布失败: ${error.message}`);
+    throw error;
+  }
+};
+
+module.exports = publishCmp;
+

package/src/module/index.js

@@ -81,11 +81,14 @@ yargs
             value: 'neo',
             short: 'neo'
           },
+          /*
+          // 暂不提供 react js 模板（react js 模板已废弃）
           {
             name: 'react 自定义组件',
             value: 'react',
             short: 'react'
           },
+          */
           {
             name: 'vue2 自定义组件',
             value: 'vue2',
@@ -169,11 +172,14 @@ yargs
           {
             name: 'cmpType',
             type: 'input',
-            message: '请输入要预览的自定义组件名称（默认 info-card）:',
-            default: 'info-card'
+            message: '请输入要预览的自定义组件名称:',
           }
         ];
         inquirer.prompt(questions).then((ans) => {
+          if (!ans.cmpType) {
+            console.error('自定义组件名称不能为空。');
+            process.exit(1);
+          }
           mainAction.previewCmp(ans.cmpType);
         });
       }
@@ -248,6 +254,40 @@ yargs
       mainAction.publish2oss(argv.cmpType); // 构建并发布脚本到oss
     }
   )
+  .command(
+    'publishCmp [options]',
+    '发布组件到 NeoCRM 平台',
+    (yargs) => {
+      yargs
+        .reset()
+        .usage(titleTip('Usage') + ': $0 publishCmp [options]')
+        .option('cmpType', {
+          alias: 't',
+          describe: '自定义组件名称'
+        })
+        .alias('h', 'help');
+    },
+    (argv) => {
+      if (argv.cmpType) {
+        mainAction.publishCmp(argv.cmpType); // 构建并发布组件到 NeoCRM
+      } else {
+        const questions = [
+          {
+            name: 'cmpType',
+            type: 'input',
+            message: '请输入要发布的自定义组件名称:'
+          }
+        ];
+        inquirer.prompt(questions).then((ans) => {
+          if (!ans.cmpType) {
+            console.error('自定义组件名称不能为空。');
+            process.exit(1);
+          }
+          mainAction.publishCmp(ans.cmpType);
+        });
+      }
+    }
+  )
   .command(
     'build2esm',
     '构建esm模块',

package/src/module/main.js

@@ -7,6 +7,7 @@ const neoConfigInit = require('../utils/neoConfigInit.js');
 const { consoleTag } = require('../utils/neoParams');
 const curConfig = require('../config/index'); // 获取当前项目根目录下的配置文件
 const publish2oss = require('../oss/publish2oss');
+const publishCmp = require('../cmpUtils/publishCmp');
 const getEntries = require('../cmpUtils/getEntries');
 const getEntriesWithAutoRegister = require('../cmpUtils/getEntriesWithAutoRegister');
 const previewCmp = require('./previewCmp');
@@ -270,5 +271,93 @@ module.exports = {
       );
     });
   },
+  // 发布组件到 NeoCRM 平台
+  publishCmp: (cmpType) => {
+    // 将 publishCmp 相关配置设置给 build2lib
+    const publishCmpConfig = curConfig.publishCmp;
+    curConfig.build2lib = Object.assign(curConfig.build2lib, publishCmpConfig);
+
+    const curEntry = curConfig.build2lib.entry;
+    let curCmpTypes = [];
+
+    if (!curEntry || Object.keys(curEntry).length === 0) {
+      // 如果未配置 entry，则自动生成 entry
+      let entries = {};
+      if (curConfig.build2lib.disableAutoRegister) {
+        // disableAutoRegister 为 true 时，仅自动生成入口文件（不自动注册）
+        const { widgetEntries, cmpTypes } = getEntries(curConfig.componentsDir, cmpType);
+        entries = widgetEntries;
+        curCmpTypes = cmpTypes;
+      } else {
+        // 自动生成入口文件（并自动创建对应的注册文件）
+        const { widgetEntries, cmpTypes } = getEntriesWithAutoRegister(
+          curConfig.componentsDir,
+          cmpType
+        );
+        entries = widgetEntries;
+        curCmpTypes = cmpTypes;
+      }
+
+      // 注入 webpack/entry
+      if (entries && Object.keys(entries).length > 0) {
+        curConfig.build2lib.entry = entries;
+        console.info('已自动生成 entry 入口配置：', entries);
+      } else {
+        console.error(
+          `未识别到自定义组件，请检查 ${
+            curConfig.componentsDir || './src/components'
+          } 目录下是否存在自定义组件。`
+        );
+        process.exit(1);
+      }
+    }
+
+    /*
+    // 说明：自定义组件和平台模块联邦使用异常，所以暂时注释掉
+    // 添加模块联邦插件
+    if (curConfig.publishCmp.enableMF) {
+      curConfig.webpack.plugins.push(...MFPlugins);
+    }
+    */
+
+    // 添加自定义 webpack 插件: 用于实现和 Neo 平台共享依赖
+    if (
+      curConfig.webpack &&
+      curConfig.webpack.plugins &&
+      Array.isArray(curConfig.webpack.plugins)
+    ) {
+      curConfig.webpack.plugins.push(new AddNeoRequirePlugin({ verbose: true }));
+    } else {
+      curConfig.webpack.plugins = [new AddNeoRequirePlugin({ verbose: true })];
+    }
+
+    // 添加 内置 Neo 的 externals 配置
+    const neoExternals = getExternalsByNeoCommonModules(cmpNeoExternals);
+    if (curConfig.build2lib.externals && _.isPlainObject(curConfig.build2lib.externals)) {
+      curConfig.build2lib.externals = Object.assign(curConfig.build2lib.externals, neoExternals);
+    } else {
+      curConfig.build2lib.externals = neoExternals;
+    }
+
+    // 写入自定义组件的共享模块和远程模块相关信息
+    const commonModulesFilePath = createCommonModulesCode(neoCommonModule, curCmpTypes);
+
+    // 所有入口文件添加 commonModulesFile
+    if (commonModulesFilePath && curConfig.build2lib.entry) {
+      Object.keys(curConfig.build2lib.entry).forEach((name) => {
+        // 判断不是以Model结尾的文件
+        if (!name.endsWith('Model')) {
+          curConfig.build2lib.entry[name] = [commonModulesFilePath].concat(
+            curConfig.build2lib.entry[name]
+          );
+        }
+      });
+    }
+
+    akfun.build('lib', curConfig, consoleTag, () => {
+      // 构建完成后，执行 publishCmp
+      publishCmp(publishCmpConfig);
+    });
+  },
   build2esm: (fileName) => akfun.build2esm(fileName, curConfig, consoleTag) // 构建esm输出模块
 };

package/src/neo/neoService.js

@@ -0,0 +1,423 @@
+const axios = require('axios');
+const FormData = require('form-data');
+const fs = require('fs');
+const path = require('path');
+const _ = require('lodash');
+const updatePublishLog = require('../cmpUtils/updatePublishLog');
+
+// NeoCRM 平台默认 API 配置
+const NeoCrmAPI = {
+  neoBaseURL: 'https://crm.xiaoshouyi.com', // 平台根地址
+  tokenAPI: 'https://login.crm.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址
+  uploadAPI: '/rest/metadata/v3.0/ui/customComponents/actions/upload', // 文件上传接口地址
+  saveAPI: '/rest/metadata/v3.0/ui/customComponents/actions/saveComponent' // 组件信息保存接口地址
+};
+
+/**
+ * Neo 平台服务类
+ * 提供 token 管理、文件上传、组件更新等功能
+ */
+class NeoService {
+  /**
+   * 初始化 Neo 服务
+   * @param {object} config 配置信息
+   * @param {string} config.neoBaseURL Neo 平台根地址
+   * @param {string} config.tokenAPI Token 获取接口地址
+   * @param {object} config.authorization 授权信息
+   * @param {string} config.authorization.client_id 客户端 ID
+   * @param {string} config.authorization.client_secret 客户端密钥
+   * @param {string} config.authorization.username 用户名
+   * @param {string} config.authorization.password 密码
+   */
+  constructor(config = {}) {
+    const { assetsRoot, neoBaseURL, tokenAPI, authorization } = config;
+    if (!authorization) {
+      throw new Error('authorization 不能为空');
+    }
+    if (
+      !authorization.client_id ||
+      !authorization.client_secret ||
+      !authorization.username ||
+      !authorization.password
+    ) {
+      throw new Error(
+        'authorization 配置不完整，需要包含 client_id、client_secret、username、password'
+      );
+    }
+
+    this.assetsRoot = assetsRoot;
+    this.neoBaseURL = neoBaseURL || NeoCrmAPI.neoBaseURL;
+    this.tokenAPI = tokenAPI || NeoCrmAPI.tokenAPI;
+    this.authorization = authorization;
+
+    // Token 缓存
+    this.tokenCache = {
+      token: null,
+      expiresAt: null
+    };
+  }
+
+  /**
+   * 构建完整的 API URL
+   * @param {string} url 相对或绝对 URL
+   * @returns {string} 完整的 URL
+   */
+  buildFullUrl(url) {
+    if (url.startsWith('http://') || url.startsWith('https://')) {
+      return url;
+    }
+    return `${this.neoBaseURL}${url}`;
+  }
+
+  // 获取文件上传接口地址
+  uploadAPI() {
+    return this.buildFullUrl(NeoCrmAPI.uploadAPI);
+  }
+
+  // 获取组件信息保存接口地址
+  saveAPI() {
+    return this.buildFullUrl(NeoCrmAPI.saveAPI);
+  }
+
+  /**
+   * 检查 token 是否过期
+   * @returns {boolean} true 表示已过期，false 表示未过期
+   */
+  isTokenExpired() {
+    if (!this.tokenCache.token || !this.tokenCache.expiresAt) {
+      return true;
+    }
+    // 提前 60 秒判断为过期，避免边缘情况
+    return Date.now() >= this.tokenCache.expiresAt;
+  }
+
+  /**
+   * 获取 token（含授权信息、租户信息）
+   * @returns {Promise<string>} token
+   */
+  async getToken() {
+    // 检查缓存是否有效
+    if (!this.isTokenExpired()) {
+      console.info('使用缓存的 token');
+      return this.tokenCache.token;
+    }
+
+    console.info('正在获取 token...');
+
+    try {
+      // 构建请求参数
+      const params = new URLSearchParams();
+      params.append('grant_type', 'password');
+      params.append('client_id', this.authorization.client_id);
+      params.append('client_secret', this.authorization.client_secret);
+      params.append('username', this.authorization.username);
+      params.append('password', this.authorization.password);
+
+      const tokenUrl = this.buildFullUrl(this.tokenAPI);
+      const response = await axios.post(tokenUrl, params, {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        }
+      });
+
+      const { access_token, expires_in } = response.data;
+
+      if (!access_token) {
+        throw new Error('获取 token 失败：响应中未包含 access_token');
+      }
+
+      // 缓存 token（提前 60 秒过期，避免边缘情况）
+      const expiresIn = parseInt(expires_in) || 3600; // 默认 1 小时
+      this.tokenCache = {
+        token: access_token,
+        expiresAt: Date.now() + (expiresIn - 60) * 1000
+      };
+
+      console.info('token 获取成功');
+      return access_token;
+    } catch (error) {
+      console.error('获取 token 失败:', error.message);
+      if (error.response) {
+        console.error('响应数据:', error.response.data);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 刷新 token
+   * @returns {Promise<string>} 新的 token
+   */
+  async refreshToken() {
+    // 清除缓存，强制获取新 token
+    this.tokenCache = {
+      token: null,
+      expiresAt: null
+    };
+
+    return await this.getToken();
+  }
+
+  /**
+   * 确保 token 有效，如果过期则自动刷新
+   * @returns {Promise<string>} 有效的 token
+   */
+  async ensureValidToken() {
+    if (this.isTokenExpired()) {
+      console.info('token 已过期，正在刷新...');
+      return await this.refreshToken();
+    }
+    return this.tokenCache.token;
+  }
+
+  /**
+   * 上传文件到 Neo 平台
+   * @param {string} filePath 文件路径
+   * @param {object} options 可选配置
+   * @param {string} options.fieldName 表单字段名，默认为 'file'
+   * @returns {Promise<string>} CDN 地址或文件 URL
+   */
+  async uploadFile(filePath, options = {}) {
+    // 确保 token 有效
+    const token = await this.ensureValidToken();
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`文件不存在: ${filePath}`);
+    }
+
+    console.info('正在上传文件...');
+
+    try {
+      const formData = new FormData();
+      const fieldName = options.fieldName || 'customComponentCode';
+      formData.append(fieldName, fs.createReadStream(filePath));
+
+      const fullUploadAPI = this.uploadAPI();
+      const response = await axios.post(fullUploadAPI, formData, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          ...formData.getHeaders()
+        }
+      });
+
+      // 处理不同的响应格式
+      let resultData;
+      if (typeof response.data === 'string') {
+        resultData = response.data;
+      } else if (response.data && response.data.data) {
+        resultData = response.data.data;
+      } else if (response.data && response.data.code === 200) {
+        resultData = response.data.data;
+      } else {
+        resultData = response.data;
+      }
+
+      if (response.data && response.data.code && response.data.code !== 200) {
+        throw new Error(`上传失败: ${response.data.message || '未知错误'}`);
+      }
+
+      if (!resultData || (typeof resultData !== 'string' && !resultData.url)) {
+        throw new Error(`返回的文件地址格式不正确: ${JSON.stringify(resultData)}`);
+      }
+
+      const fileUrl = typeof resultData === 'string' ? resultData : resultData.url;
+      return fileUrl;
+    } catch (error) {
+      console.error('上传文件失败:', error.message);
+      if (error.response) {
+        console.error('响应数据:', error.response.data);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 将构建产物上传到 NeoCRM 平台端
+   *
+   * @param {object} cmpType 自定义组件名称
+   * @param {array} fileExtensions 需要上传的文件类型，默认 ['.js', '.css']
+   */
+  async publish2oss(cmpType, fileExtensions = ['.js', '.css']) {
+    if (!fs.existsSync(cmpType)) {
+      console.error(`自定义组件名称不能为空: ${cmpType}`);
+      return;
+    }
+    if (!fs.existsSync(this.assetsRoot)) {
+      console.error(`未找到自定义组件资源目录: ${this.assetsRoot}`);
+      return;
+    }
+    // 当前组件信息
+    const curCmpInfo = {
+      cmpType
+    };
+
+    const files = fs.readdirSync(this.assetsRoot); // 读取构建目录下的所有文件
+
+    // 并行上传所有指定类型的文件
+    const uploadPromises = files.map(async (file) => {
+      const filePath = path.join(this.assetsRoot, file);
+      // 获取文件状态
+      const fileStat = fs.statSync(filePath);
+      // 检查文件扩展名
+      // const fileExt = path.extname(file);
+      const fileInfo = path.parse(filePath);
+      if (fileStat.isFile() && fileExtensions.includes(fileInfo.ext)) {
+        let widgetName = _.kebabCase(cmpType);
+
+        if (file.indexOf(widgetName) < 0) {
+          return;
+        }
+
+        try {
+          // 上传文件
+          const fileUrl = await this.uploadFile(filePath);
+          
+          if (file.indexOf('Model') > -1) {
+            curCmpInfo.modelAsset = fileUrl;
+          } else if (file.endsWith('.css')) {
+            curCmpInfo.cssAsset = fileUrl;
+          } else {
+            curCmpInfo.asset = fileUrl;
+          }
+
+        } catch (error) {
+          console.error(`文件上传失败（${file}）：\n`, error);
+        }
+      }
+    });
+
+    await Promise.all(uploadPromises);
+    
+    if (curCmpInfo && curCmpInfo.cmpType) {
+      console.info('上传至 OSS 的文件信息：\n', curCmpInfo);
+      // 更新发布日志
+      updatePublishLog(curCmpInfo);
+    }
+    return curCmpInfo;
+  }
+
+  /**
+   * 更新自定义组件
+   * @param {string} updateAPI 更新接口地址（相对或绝对路径）
+   * @param {object} componentData 组件数据
+   * @returns {Promise<object>} 更新结果
+   */
+  async updateCustomComponent(componentData) {
+    // 确保 token 有效
+    const token = await this.ensureValidToken();
+
+    if (!componentData) {
+      throw new Error('componentData 不能为空');
+    }
+
+    console.info('正在更新自定义组件...');
+
+    try {
+      const fullUpdateAPI = this.updateAPI();
+      const response = await axios.post(fullUpdateAPI, componentData, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json'
+        }
+      });
+
+      if (response.data && response.data.code && response.data.code !== 200) {
+        throw new Error(`更新组件失败: ${response.data.message || '未知错误'}`);
+      }
+
+      console.info('组件更新成功:', response.data);
+      return response.data;
+    } catch (error) {
+      console.error('更新组件失败:', error.message);
+      if (error.response) {
+        console.error('响应数据:', error.response.data);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 通用请求方法（确保 token 有效）
+   * @param {string} method HTTP 方法
+   * @param {string} api API 地址（相对或绝对路径）
+   * @param {object} options 请求选项
+   * @param {object} options.data 请求数据
+   * @param {object} options.headers 额外的请求头
+   * @param {object} options.params 查询参数
+   * @returns {Promise<object>} 响应数据
+   */
+  async request(method, api, options = {}) {
+    // 确保 token 有效
+    const token = await this.ensureValidToken();
+
+    const { data, headers = {}, params } = options;
+    const fullAPI = this.buildFullUrl(api);
+
+    try {
+      const response = await axios({
+        method,
+        url: fullAPI,
+        data,
+        params,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          ...headers
+        }
+      });
+
+      if (response.data && response.data.code && response.data.code !== 200) {
+        throw new Error(`请求失败: ${response.data.message || '未知错误'}`);
+      }
+
+      return response.data;
+    } catch (error) {
+      console.error(`请求失败 [${method} ${api}]:`, error.message);
+      if (error.response) {
+        console.error('响应数据:', error.response.data);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * GET 请求
+   * @param {string} api API 地址
+   * @param {object} options 请求选项
+   * @returns {Promise<object>} 响应数据
+   */
+  async get(api, options = {}) {
+    return await this.request('GET', api, options);
+  }
+
+  /**
+   * POST 请求
+   * @param {string} api API 地址
+   * @param {object} options 请求选项
+   * @returns {Promise<object>} 响应数据
+   */
+  async post(api, options = {}) {
+    return await this.request('POST', api, options);
+  }
+
+  /**
+   * PUT 请求
+   * @param {string} api API 地址
+   * @param {object} options 请求选项
+   * @returns {Promise<object>} 响应数据
+   */
+  async put(api, options = {}) {
+    return await this.request('PUT', api, options);
+  }
+
+  /**
+   * DELETE 请求
+   * @param {string} api API 地址
+   * @param {object} options 请求选项
+   * @returns {Promise<object>} 响应数据
+   */
+  async delete(api, options = {}) {
+    return await this.request('DELETE', api, options);
+  }
+}
+
+module.exports = NeoService;

package/src/oss/publish2oss.js

@@ -10,101 +10,6 @@ const updatePublishLog = require('../cmpUtils/updatePublishLog');
 const currentPackageJsonDir = catchCurPackageJson();
 const currentPackageJson = getConfigObj(currentPackageJsonDir);
 
-/**
- * 将构建产物上传到指定 oss 存储桶
- *
- * @param {string} ossType  oss 类型：baidu、ali
- * @param {object} ossConfig  oss 配置
- * @param {string} assetsRoot 构建产物的目录
- * @param {array} fileExtensions 需要上传的文件类型，默认 ['.js', '.css']
- */
-const publish2oss = (ossType, ossConfig, assetsRoot, fileExtensions = ['.js', '.css']) => {
-  if (ossType !== 'baidu' && ossType !== 'ali') {
-    console.error(`不支持的oss类型: ${ossType}`);
-    return;
-  }
-  const bosClient = getBosClient(ossType, ossConfig);
-  if (!assetsRoot) {
-    console.error('assetsRoot 不能为空');
-    return;
-  }
-  if (!fs.existsSync(assetsRoot)) {
-    console.error(`assetsRoot 不存在: ${assetsRoot}`);
-    return;
-  }
-  const files = fs.readdirSync(assetsRoot); // 读取构建目录下的所有文件
-
-  // 并行上传所有指定类型的文件
-  const uploadPromises = files.map(async (file) => {
-    const filePath = path.join(assetsRoot, file);
-    // 获取文件状态
-    const fileStat = fs.statSync(filePath);
-    // 检查文件扩展名
-    // const fileExt = path.extname(file);
-    const fileInfo = path.parse(filePath);
-    if (fileStat.isFile() && fileExtensions.includes(fileInfo.ext)) {
-      const objectKey = addVersionToFilename(file);
-      try {
-        // 判断线上是否存在重名文件，避免被覆盖
-        const historyResult = await bosClient.get(objectKey);
-        if (historyResult && historyResult.url) {
-          return {
-            success: false,
-            status: '文件上传失败',
-            widgetName: fileInfo.name,
-            fileName: file,
-            filepath: filePath,
-            ossPath: historyResult.url,
-            error: '线上存在重名文件。'
-          };
-        }
-        // 上传文件
-        const result = await bosClient.upload(objectKey, filePath);
-        return {
-          success: true,
-          status: '文件上传成功',
-          fileName: file,
-          widgetName: fileInfo.name,
-          filepath: filePath,
-          ossPath: getFilePath(ossType, ossConfig.bucket, objectKey),
-          resultMsg: result
-        };
-      } catch (error) {
-        return {
-          success: false,
-          status: '文件上传失败',
-          widgetName: fileInfo.name,
-          fileName: file,
-          filepath: filePath,
-          error: error.message
-        };
-      }
-    }
-  });
-
-  Promise.all(uploadPromises)
-    .then((results) => {
-      /*
-      const { succeedFiles, errorFiles } = getResultFiles(results);
-      if (succeedFiles.length > 0) {
-        console.info('已成功上传如下文件：\n', succeedFiles);
-      }
-      if (errorFiles.length > 0) {
-        console.info('上传失败的文件有：\n', errorFiles);
-      }
-      */
-      const widgetFilesMap = getResultFilesByWidgetName(results);
-      if (widgetFilesMap) {
-        console.info('上传至 OSS 的文件信息：\n', widgetFilesMap);
-        // 更新发布日志
-        updatePublishLog(widgetFilesMap);
-      }
-    })
-    .catch((error) => {
-      console.error('批量上传文件异常：\n', error);
-    });
-};
-
 // 根据 ossType 获取对应的 BosClient
 const getBosClient = (ossType, ossConfig) => {
   if (ossType === 'baidu') {
@@ -241,4 +146,99 @@ function addVersionToFilename(
   return `${projectName}/${baseName}-${version}${extension}`;
 }
 
+/**
+ * 将构建产物上传到指定 oss 存储桶
+ *
+ * @param {string} ossType  oss 类型：baidu、ali
+ * @param {object} ossConfig  oss 配置
+ * @param {string} assetsRoot 构建产物的目录
+ * @param {array} fileExtensions 需要上传的文件类型，默认 ['.js', '.css']
+ */
+const publish2oss = (ossType, ossConfig, assetsRoot, fileExtensions = ['.js', '.css']) => {
+  if (ossType !== 'baidu' && ossType !== 'ali') {
+    console.error(`不支持的oss类型: ${ossType}`);
+    return;
+  }
+  const bosClient = getBosClient(ossType, ossConfig);
+  if (!assetsRoot) {
+    console.error('assetsRoot 不能为空');
+    return;
+  }
+  if (!fs.existsSync(assetsRoot)) {
+    console.error(`assetsRoot 不存在: ${assetsRoot}`);
+    return;
+  }
+  const files = fs.readdirSync(assetsRoot); // 读取构建目录下的所有文件
+
+  // 并行上传所有指定类型的文件
+  const uploadPromises = files.map(async (file) => {
+    const filePath = path.join(assetsRoot, file);
+    // 获取文件状态
+    const fileStat = fs.statSync(filePath);
+    // 检查文件扩展名
+    // const fileExt = path.extname(file);
+    const fileInfo = path.parse(filePath);
+    if (fileStat.isFile() && fileExtensions.includes(fileInfo.ext)) {
+      const objectKey = addVersionToFilename(file);
+      try {
+        // 判断线上是否存在重名文件，避免被覆盖
+        const historyResult = await bosClient.get(objectKey);
+        if (historyResult && historyResult.url) {
+          return {
+            success: false,
+            status: '文件上传失败',
+            widgetName: fileInfo.name,
+            fileName: file,
+            filepath: filePath,
+            ossPath: historyResult.url,
+            error: '线上存在重名文件。'
+          };
+        }
+        // 上传文件
+        const result = await bosClient.upload(objectKey, filePath);
+        return {
+          success: true,
+          status: '文件上传成功',
+          fileName: file,
+          widgetName: fileInfo.name,
+          filepath: filePath,
+          ossPath: getFilePath(ossType, ossConfig.bucket, objectKey),
+          resultMsg: result
+        };
+      } catch (error) {
+        return {
+          success: false,
+          status: '文件上传失败',
+          widgetName: fileInfo.name,
+          fileName: file,
+          filepath: filePath,
+          error: error.message
+        };
+      }
+    }
+  });
+
+  Promise.all(uploadPromises)
+    .then((results) => {
+      /*
+      const { succeedFiles, errorFiles } = getResultFiles(results);
+      if (succeedFiles.length > 0) {
+        console.info('已成功上传如下文件：\n', succeedFiles);
+      }
+      if (errorFiles.length > 0) {
+        console.info('上传失败的文件有：\n', errorFiles);
+      }
+      */
+      const widgetFilesMap = getResultFilesByWidgetName(results);
+      if (widgetFilesMap) {
+        console.info('上传至 OSS 的文件信息：\n', widgetFilesMap);
+        // 更新发布日志
+        updatePublishLog(widgetFilesMap);
+      }
+    })
+    .catch((error) => {
+      console.error('批量上传文件异常：\n', error);
+    });
+};
+
 module.exports = publish2oss;

package/src/template/neo-custom-cmp-template/README.md

@@ -2,8 +2,8 @@
 - src: 自定义组件源码；
 - src/assets: 存放组件静态资源，比如 css、img等；
 - src/components: 存放自定义组件代码，每个自定义组件以自身名称（cmpType 数值）作为目录进行存放；
-- src/components/contact-form/index.tsx: 自定义组件的内容文件；
-- src/components/contact-form/model.ts: 自定义组件的模型文件，用于对接页面设计器；
+- src/components/entity-table/index.tsx: 自定义组件的内容文件；
+- src/components/entity-table/model.ts: 自定义组件的模型文件，用于对接页面设计器；
 - neo.config.js: neo-cmp-cli 配置文件。
 
 ### 组件开发规范
@@ -13,7 +13,7 @@
 - 自定义组件最外层请设置一个唯一的 ClassName（比如 xx-cmpType-container），所有内容样式请放在该 ClassName 中，避免自定义组件样式相互干扰；
 - 默认开启代码规范检测（含样式内容），如需关闭，请调整 neo.config.js 相关配置；
 - 请使用 react 16版本；
-- 支持在自定义组件中使用 Open API，详细见[使用说明](./docs/README.md)。
+- 支持在自定义组件中使用 Open API，详细见[使用说明](https://www.npmjs.com/package/neo-open-api)。
 
 ### 自定义组件注册器使用说明
 - [neo-register 使用说明](https://www.npmjs.com/package/neo-register?activeTab=readme)

package/src/template/neo-custom-cmp-template/auth.config.js

@@ -0,0 +1,12 @@
+'use strict';
+// NeoCRM 授权配置
+module.exports = {
+  client_id: 'xx', // 客户端 ID，从创建连接器的客户端信息中获取（Client_Id）
+  client_secret: 'xxx', // 客户端秘钥，从创建连接器的客户端信息中获取（Client_Secret）
+  username: 'xx', // 用户在销售易系统中的用户名
+  /**
+   * password 为 用户在销售易系统中的账号密码加上 8 位安全令牌。
+   * 例如，用户密码为 123456，安全令牌为 ABCDEFGH，则 password 的值应为 123456ABCDEFGH。
+   */
+  password: 'xx xx', // 用户账户密码 + 8 位安全令牌
+};

package/src/template/neo-custom-cmp-template/neo.config.js

@@ -6,6 +6,12 @@ function resolve(dir) {
   return path.resolve(__dirname, dir);
 }
 
+let authConfig = {}; // NeoCRM 授权配置
+if (fs.existsSync('./auth.config.js')) {
+  // 加载 NeoCRM 授权配置
+  authConfig = require('./auth.config');
+}
+
 // 包括生产和开发的环境配置信息
 module.exports = {
   settings: {
@@ -121,15 +127,18 @@ module.exports = {
   },
   publishCmp: {
     // 用于构建并发布至 NeoCRM 的相关配置
-    credentials: {
-      client_id: 'xx', // 客户端 ID，从创建连接器的客户端信息中获取（Client_Id）
-      client_secret: 'xxx', // 客户端秘钥，从创建连接器的客户端信息中获取（Client_Secret）
-      username: 'xx', // 用户在销售易系统中的用户名
+    neoBaseURL: 'https://crm-cd.xiaoshouyi.com', // 平台根地址（默认：https://crm.xiaoshouyi.com）
+    tokenAPI: 'https://login.crm-cd.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址（默认：https://login.crm.xiaoshouyi.com/auc/oauth2/token）
+    // NeoCRM 授权配置
+    authorization: {
+      client_id: authConfig.client_id || 'xx', // 客户端 ID，从创建连接器的客户端信息中获取（Client_Id）
+      client_secret: authConfig.client_secret || 'xxx', // 客户端秘钥，从创建连接器的客户端信息中获取（Client_Secret）
+      username: authConfig.username || 'xx', // 用户在销售易系统中的用户名
       /**
        * password 为 用户在销售易系统中的账号密码加上 8 位安全令牌。
        * 例如，用户密码为 123456，安全令牌为 ABCDEFGH，则 password 的值应为 123456ABCDEFGH。
        */
-      password: 'xx xx' // 用户账户密码 + 8 位安全令牌
+      password: authConfig.password || 'xx xx' // 用户账户密码 + 8 位安全令牌
     },
     /*
     【特别说明】以下配置项都自带默认值，非必填。如需自定义请自行配置。

package/src/template/react-custom-cmp-template/.prettierrc.js

@@ -6,7 +6,7 @@ module.exports = {
   semi: true, // Semicolons 分号，默认需要分号
   tabWidth: 2, // 空格，默认 2,
   useTabs: false,
-  singleQuote: true, // 单引号还是双引号，默认为false 双引号
+  singleQuote: true, // 单引号还是双引号，默认为 false 双引号
   trailingComma: 'all', // 逗号
   jsxBracketSameLine: false, // 默认为false，Put the > of a multi-line JSX element at the end of the last line instead of being alone on the next line (does not apply to self closing elements).
 };