shoplazza-cli 1.0.12 → 1.1.1

package/lib/app/services/extension-build/buildTheme.js

@@ -0,0 +1,100 @@
+const path = require('path');
+const fs = require('fs/promises');
+const chalk = require('chalk');
+const AdmZip = require('adm-zip');
+const crypto = require('crypto');
+
+/**
+ * 计算文件夹内容的哈希值
+ * @param {string} dirPath - 文件夹路径
+ * @returns {Promise<string>} 返回基于文件夹内容的哈希值
+ */
+async function calculateFolderHash(dirPath) {
+  if (!(await pathExists(dirPath))) {
+    throw new Error(chalk.red(`Calculate folder hash path does not exist: ${dirPath}`));
+  }
+
+  const hash = crypto.createHash('md5');
+
+  async function walk(currentPath) {
+    const stat = await fs.stat(currentPath);
+    if (stat.isDirectory()) {
+      const entries = (await fs.readdir(currentPath)).sort(); // 排序保证跨平台一致
+      for (const entry of entries) {
+        await walk(path.join(currentPath, entry));
+      }
+    } else {
+      const content = await fs.readFile(currentPath);
+      hash.update(content);
+    }
+  }
+
+  await walk(dirPath);
+  return hash.digest('hex');
+}
+
+/**
+ * 检查路径是否存在
+ * @param {string} targetPath
+ * @returns {Promise<boolean>}
+ */
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 压缩目录或文件
+ * @param {string} sourcePath - 需要压缩的目录或文件路径
+ * @param {string} outputDir - 压缩文件输出目录
+ * @param {Object} [options] - 压缩选项
+ * @param {string} [options.rename] - 压缩包中目录的重命名
+ * @returns {Promise<Object>} 返回压缩文件路径和文件名
+ */
+async function compress(sourcePath, outputDir, options = {}) {
+  const { rename } = options;
+
+  if (!(await pathExists(sourcePath))) {
+    throw new Error(chalk.red(`Compress path does not exist: ${sourcePath}`));
+  }
+
+  const sourceName = path.basename(sourcePath);
+  const sourceHash = await calculateFolderHash(sourcePath);
+  const fileName = `${sourceName}-${sourceHash.substring(0, 8)}${Date.now().toString(16).substring(0, 8)}.zip`;
+  const outputPath = path.resolve(outputDir, fileName);
+
+  // 确保输出目录存在
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+
+  return new Promise(async (resolve, reject) => {
+    const zip = new AdmZip();
+    const stat = await fs.stat(sourcePath);
+
+    if (stat.isDirectory()) {
+      zip.addLocalFolder(sourcePath, rename || sourceName);
+    } else {
+      zip.addLocalFile(sourcePath);
+    }
+
+    zip.writeZip(outputPath, (err) => {
+      if (err) reject(err);
+      else resolve({ zipPath: outputPath, zipName: fileName });
+    });
+  });
+}
+
+async function buildTheme(extension) {
+  const extensionDir = path.dirname(extension.configPath);
+
+  const outputDir = path.join(extensionDir, '..', '..', 'app-deploy');
+  const zipInfo = await compress(extensionDir, outputDir, { rename: 'theme-app' });
+  return zipInfo.zipPath; // 返回压缩包路径
+}
+
+module.exports = {
+  buildTheme
+};

package/lib/app/services/extension-build/index.js

@@ -0,0 +1,23 @@
+const { buildFunction } = require('./buildFunction');
+const { buildCheckout } = require('./buildCheckout');
+const { buildTheme } = require('./buildTheme');
+const { EXTENSION_TYPES } = require('../../constant/extension');
+
+const strategies = {
+  [EXTENSION_TYPES.THEME]: buildTheme,
+  [EXTENSION_TYPES.CHECKOUT]: buildCheckout,
+  [EXTENSION_TYPES.FUNCTION]: buildFunction
+};
+
+async function buildExtension(extension) {
+  const strategy = strategies[extension.extension_type];
+  if (strategy) {
+    return strategy(extension);
+  }
+
+  throw new Error(`Unsupported extension type: ${extension.extension_type}`);
+}
+
+module.exports = {
+  buildExtension
+};

package/lib/app/services/extension-build/plugins/vite-plugin-add-extension-id.js

@@ -0,0 +1,26 @@
+const parseExtension = (str, name) => {
+  const data = str.split(/(?:import\s*(?:.*?)\s*from\s*(?:.*?)\s*;)/g);
+  const main = data[data.length - 1];
+  const id = JSON.stringify(name);
+  const importString = str.match(/(?:import\s*(?:.*?)\s*from\s*(?:.*?)\s*;)/g)?.join(' ') || '';
+  return `${importString}(function(){const __EXTENSION_ID__=${id};${main}})()`;
+};
+
+module.exports = {
+  vitePluginAddExtensionId: function (id) {
+    return {
+      name: 'vitePluginAddExtensionId',
+      enforce: 'pre',
+      apply: 'build',
+      transform: (code, _id) => {
+        if (/.*\/extensions\/.*\/src\/index\.js/.test(_id)) {
+          return parseExtension(code, id);
+        }
+        return code;
+      },
+      buildEnd: () => {
+        console.log('vitePluginAddExtensionId end');
+      }
+    };
+  }
+};

package/lib/app/services/extension-build/plugins/vite-plugin-transform-extension-html.js

@@ -0,0 +1,207 @@
+const fs = require('fs');
+const path = require('path');
+const j = require('jscodeshift');
+
+const EXTENSION_RENDER_FN_NAME = 'extend';
+const HTML_FILE_PATH_KEY = 'component';
+const ASTNodeType = {
+  RETURN_STATMENT: 'ReturnStatement',
+  CALL_EXPRESSION: 'CallExpression',
+  OBJECT_EXPRESSION: 'ObjectExpression',
+  IDENTIFIER: 'Identifier',
+  IMPORT_DEFAULT_SPECIFIER: 'ImportDefaultSpecifier',
+  IMPORT_DECLARATION: 'ImportDeclaration'
+};
+const findRenderFnList = (code) => {
+  const renderFnList = [];
+
+  j(code)
+    .find(j.CallExpression)
+    .forEach((astNode) => {
+      if (astNode?.value?.callee?.name === EXTENSION_RENDER_FN_NAME) {
+        const objectExpressionNode = astNode?.value?.arguments?.find(
+          (args) => args.type === ASTNodeType.OBJECT_EXPRESSION
+        );
+        if (objectExpressionNode) {
+          const componentProp = objectExpressionNode?.properties?.find(
+            (prop) => prop?.key?.name === HTML_FILE_PATH_KEY
+          );
+
+          const name = componentProp?.value?.callee?.name;
+          name && renderFnList.push(name);
+        }
+      }
+    });
+
+  return renderFnList;
+};
+
+const findImportDeclareStatementNodeList = (code) => {
+  const importDeclareStatementList = [];
+
+  j(code)
+    .find(j.ImportDeclaration)
+    .forEach((importStatementNode) => {
+      const importDefaultSpecifier = importStatementNode?.value?.specifiers?.find(
+        (specifierNode) => specifierNode?.type === ASTNodeType.IMPORT_DEFAULT_SPECIFIER
+      )?.local?.name;
+      const importPath = importStatementNode?.value?.source?.value;
+
+      importDefaultSpecifier &&
+        importPath &&
+        typeof importPath === 'string' &&
+        importDeclareStatementList.push({ importDefaultSpecifier, importPath });
+    });
+
+  return importDeclareStatementList;
+};
+
+const readFile = (path) => {
+  const supportedExt = ['html'];
+
+  const ext = path.split('.').pop()?.toLowerCase() || '';
+  if (supportedExt.includes(ext)) {
+    return fs.readFileSync(path, {
+      encoding: 'utf8'
+    });
+  }
+
+  return '';
+};
+
+const removeBodyMark = (code) => {
+  return code.replaceAll(/\<body\>/g, '').replaceAll(/\<\/body\>/g, '');
+};
+
+const addExtensionApiPrefix = (code) => {
+  const EXTENSION_API_CALL_EXPRESSION = '__EXTENSION_UI__.extensionApi.';
+  return code.replaceAll(/extensionApi\./g, EXTENSION_API_CALL_EXPRESSION);
+};
+
+let cachedHtmlStr = {};
+
+const handleHtmlDeps = (htmlStr, curPath) => {
+  let str = htmlStr;
+  // eg. import "./index.html" import './index.html'
+  const importReg = /import\s*(?:(?:\"([\.\/\w]+)\")|(?:'([\.\/\w]+)'))/;
+
+  let result = importReg.exec(str);
+  while (result) {
+    const importedHtmlPath = result[1] || result[2];
+    if (importedHtmlPath) {
+      try {
+        const importedHtmlAbsolutePath = path.resolve(path.dirname(curPath), importedHtmlPath);
+        if (!Object.prototype.hasOwnProperty.call(cachedHtmlStr, importedHtmlAbsolutePath)) {
+          cachedHtmlStr[importedHtmlAbsolutePath] = '';
+
+          const importedHtmlStr = readFile(importedHtmlAbsolutePath);
+
+          cachedHtmlStr[importedHtmlAbsolutePath] = handleHtmlDeps(importedHtmlStr, curPath);
+        }
+
+        str = str.replace(importReg, () => cachedHtmlStr[importedHtmlAbsolutePath]);
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    result = importReg.exec(str);
+  }
+
+  str = removeBodyMark(str);
+
+  return str;
+};
+
+const strMinify = (code) => code.split('\n').filter(Boolean).join('');
+
+const createTemplateLiteral = (code) => j.stringLiteral(code);
+
+const removeImportDeclareStatment = (code, specifiers) => {
+  return j(code)
+    .find(j.Program)
+    .forEach((program) => {
+      const body = program?.value?.body || [];
+      if (body.length > 0) {
+        const index = body.findIndex(
+          (node) =>
+            node?.type === ASTNodeType.IMPORT_DECLARATION &&
+            !!node?.specifiers?.find(
+              (specifier) =>
+                specifier?.type === ASTNodeType.IMPORT_DEFAULT_SPECIFIER &&
+                specifiers.includes(specifier?.local?.name || '')
+            )
+        );
+        if (index > -1) program.value.body.splice(index, 1);
+      }
+    })
+    .toSource();
+};
+module.exports = {
+  vitePluginTransformExtensionHtml: () => {
+    return {
+      name: 'vitePluginTransformExtensionHtml',
+      enforce: 'pre',
+      apply: 'build',
+      transform(code, srcPath) {
+        if (!srcPath.endsWith('.js')) {
+          return code;
+        }
+
+        const renderFnList = findRenderFnList(code);
+        const importDeclareStatementList = findImportDeclareStatementNodeList(code);
+
+        const removedImportSpecifiers = [];
+
+        const returnStatementChangedCode = j(code)
+          .find(j.FunctionDeclaration)
+          .forEach((functionDeclareNode) => {
+            const fnName = functionDeclareNode?.value?.id?.name || '';
+            if (!renderFnList.includes(fnName)) return;
+
+            const returnStatment = functionDeclareNode?.value?.body?.body?.find(
+              (node) => node.type === ASTNodeType.RETURN_STATMENT
+            );
+
+            const isIdentifierReturnType = returnStatment?.argument?.type === ASTNodeType.IDENTIFIER;
+            if (!isIdentifierReturnType) return;
+
+            const identifierName = returnStatment?.argument?.name;
+            const htmlFilePathNode = importDeclareStatementList.find(
+              (stat) => stat.importDefaultSpecifier === identifierName
+            );
+
+            if (htmlFilePathNode) {
+              try {
+                const absolutePath = path.resolve(path.dirname(srcPath), htmlFilePathNode.importPath);
+                cachedHtmlStr[absolutePath] = '';
+                const htmlStr = readFile(absolutePath);
+
+                let result = handleHtmlDeps(htmlStr, srcPath);
+                cachedHtmlStr = {};
+
+                result = strMinify(result);
+                result = addExtensionApiPrefix(result);
+                const templateLiteral = createTemplateLiteral(result);
+
+                returnStatment.argument = templateLiteral;
+
+                removedImportSpecifiers.push(identifierName);
+              } catch (e) {
+                console.error(e);
+              }
+            }
+          })
+          .toSource();
+
+        const importStatementRemovedCode = removeImportDeclareStatment(
+          returnStatementChangedCode,
+          removedImportSpecifiers
+        );
+        return importStatementRemovedCode;
+      },
+      buildEnd: () => {
+        console.log('transform html end');
+      }
+    };
+  }
+};

package/lib/app/services/extension-diff/index.js

@@ -0,0 +1,132 @@
+const chalk = require('chalk');
+
+/**
+ * @typedef {Object} Extension
+ * @property {string} [extension_id] 扩展ID
+ * @property {string} extension_name 扩展名称
+ * @property {string} extension_type 扩展类型 theme | checkout | function
+ * @property {string} [extension_version] 扩展版本
+ * @property {string} [extension_version_id] 扩展版本ID
+ * @property {string} [resource_url] 资源地址
+ */
+
+/**
+ * 高阶匹配函数
+ * @param {Array<Extension>} localList
+ * @param {Array<Extension>} remoteList
+ * @param {(local: Extension, remote: Extension) => boolean} matchFn 匹配条件
+ * @param {(local: Extension, remote: Extension) => void} [updateFn] 匹配成功时的更新规则
+ */
+function matchAndExtract(localList, remoteList, matchFn, updateFn) {
+  const matched = [];
+  const remainingLocal = [];
+  const remainingRemote = [...remoteList];
+
+  for (const local of localList) {
+    const idx = remainingRemote.findIndex((remote) => matchFn(local, remote));
+    if (idx !== -1) {
+      if (updateFn) updateFn(local, remainingRemote[idx]);
+      matched.push(local);
+      remainingRemote.splice(idx, 1);
+    } else {
+      remainingLocal.push(local);
+    }
+  }
+
+  return { matched, remainingLocal, remainingRemote };
+}
+
+/**
+ * 默认的 CLI 交互函数（依赖 inquirer）
+ */
+async function defaultPrompt(localExt, sameTypeRemoteExtensions) {
+  const inquirer = require('inquirer');
+  const { isUseRemoteExt } = await inquirer.prompt({
+    type: 'confirm',
+    name: 'isUseRemoteExt',
+    message: `Do you want to reuse the extension ${chalk.green(localExt.extension_name)} (${chalk.green(
+      localExt.extension_type
+    )})?`,
+    default: true
+  });
+  if (!isUseRemoteExt) return null;
+
+  const { selected } = await inquirer.prompt({
+    type: 'list',
+    name: 'selected',
+    message: `Please select the extension to match ${chalk.green(localExt.extension_name)} (${chalk.green(
+      localExt.extension_type
+    )})`,
+    choices: sameTypeRemoteExtensions.map((remoteExt) => ({
+      name: remoteExt.extension_name,
+      value: remoteExt
+    }))
+  });
+
+  return selected;
+}
+
+/**
+ * 对比本地扩展和远程扩展
+ * @param {Array<Extension>} localExtensions
+ * @param {Array<Extension>} remoteExtensions
+ * @param {Object} [options]
+ * @param {(localExt: Extension, candidates: Array<Extension>) => Promise<Extension|null>} [options.promptFn] 自定义交互函数
+ * @returns {Promise<{updateExtensions: Extension[], deleteExtensions: Extension[], addExtensions: Extension[]}>}
+ */
+async function extensionDiff(localExtensions, remoteExtensions, { promptFn = defaultPrompt } = {}) {
+  let updateExtensions = [];
+  let localRest = [...localExtensions];
+  let remoteRest = [...remoteExtensions];
+  let matched = [];
+
+  // 1. 按 ID 匹配
+  ({
+    matched,
+    remainingLocal: localRest,
+    remainingRemote: remoteRest
+  } = matchAndExtract(localRest, remoteRest, (l, r) => !!l.extension_id && l.extension_id === r.extension_id));
+  updateExtensions.push(...matched);
+
+  // 2. 按 title+type 匹配
+  ({
+    matched,
+    remainingLocal: localRest,
+    remainingRemote: remoteRest
+  } = matchAndExtract(
+    localRest,
+    remoteRest,
+    (l, r) => l.extension_name === r.extension_name && l.extension_type === r.extension_type,
+    (l, r) => {
+      if (r.extension_id) l.extension_id = r.extension_id;
+    }
+  ));
+  updateExtensions.push(...matched);
+
+  // 3. 按 type 匹配（需要交互）
+  for (const localExt of [...localRest]) {
+    const sameTypeRemote = remoteRest.filter((r) => r.extension_type === localExt.extension_type);
+    if (sameTypeRemote.length === 0) continue;
+
+    const selected = await promptFn(localExt, sameTypeRemote);
+    if (selected) {
+      localExt.extension_id = selected.extension_id;
+      updateExtensions.push(localExt);
+      localRest = localRest.filter((l) => l !== localExt);
+      remoteRest = remoteRest.filter((r) => r.extension_id !== selected.extension_id);
+    }
+  }
+
+  // 4. 剩余 local → 新增
+  const addExtensions = localRest.map((localExt) => ({
+    ...localExt,
+    extension_id: ''
+  }));
+
+  // 5. 剩余 remote → 删除
+  const deleteExtensions = remoteRest;
+
+  return { updateExtensions, deleteExtensions, addExtensions };
+}
+
+module.exports = { extensionDiff, defaultPrompt };

package/lib/app/services/extension-upsert/index.js

@@ -0,0 +1,21 @@
+const upsertFunction = require('./upsertFunction');
+const upsertCheckout = require('./upsertCheckout');
+const upsertTheme = require('./upsertTheme');
+
+const strategies = {
+  function: upsertFunction,
+  checkout: upsertCheckout,
+  theme: upsertTheme
+};
+
+async function upsertExtension(extension, appClientId, partnerId, appAccessToken) {
+  const strategy = strategies[extension.extension_type];
+  if (!strategy) {
+    throw new Error(`Unsupported extension type: ${extension.extension_type}`);
+  }
+  return strategy(extension, appClientId, partnerId, appAccessToken);
+}
+
+module.exports = {
+  upsertExtension
+};

package/lib/app/services/extension-upsert/upsertCheckout.js

@@ -0,0 +1,44 @@
+const { createCheckoutExtensionRequest, commitCheckoutExtensionRequest } = require('../../api/openapi');
+
+// 提取 返回结果
+function extractCheckoutResult(res) {
+  return {
+    extension_id: res.data.extension.extension_id,
+    extension_version: res.data.extension.version,
+    extension_version_id: res.data.extension.id
+  };
+}
+
+async function upsertCheckout(extension, appClientId, partnerId, appAccessToken) {
+  // 有 extension_id 则 升级，没有则创建
+  if (extension.extension_id && extension.extension_version) {
+    // 升级
+    const res = await commitCheckoutExtensionRequest(appClientId, partnerId, {
+      name: extension.extension_name,
+      version: extension.extension_version,
+      extension_id: extension.extension_id,
+      resource_url: extension.resource_url
+    });
+
+    if (res?.status === 0) {
+      return extractCheckoutResult(res);
+    }
+
+    throw new Error(res?.message || 'upsert checkout extension failed');
+  } else {
+    // 创建
+    const res = await createCheckoutExtensionRequest(appClientId, partnerId, {
+      version: '1.0.0',
+      name: extension.extension_name,
+      resource_url: extension.resource_url
+    });
+
+    if (res?.status === 0) {
+      return extractCheckoutResult(res);
+    }
+
+    throw new Error(res?.message || 'upsert checkout extension failed');
+  }
+}
+
+module.exports = upsertCheckout;

package/lib/app/services/extension-upsert/upsertFunction.js

@@ -0,0 +1,52 @@
+const { commitFunctionRequest, createFunctionRequest } = require('../../api/partnerOpenapi');
+const path = require('path');
+
+const NAMESPACE = 'cart_transform';
+
+// 提取 返回结果
+function extractFunctionResult(res) {
+  return {
+    extension_id: res.data.function_id,
+    extension_version: res.data.version,
+    extension_version_id: res.data.version_id
+  };
+}
+
+async function upsertFunction(extension, appClientId, partnerId, appAccessToken) {
+  const sourceCodePath = path.join(extension.configPath, '..', 'src', 'index.js');
+
+  // 有 version_id 则 升级，没有则创建
+  if (extension.extension_id && extension.extension_version) {
+    // 升级
+    const res = await commitFunctionRequest(appClientId, appAccessToken.access_token, {
+      name: extension.extension_name,
+      namespace: NAMESPACE,
+      source_code: sourceCodePath,
+      file: extension.distPath,
+      function_id: extension.extension_id,
+      version: extension.extension_version
+    });
+
+    if (res?.code === 'SUCCESS') {
+      return extractFunctionResult(res);
+    }
+
+    throw new Error(res?.message || 'commit function extension failed');
+  } else {
+    // 创建
+    const res = await createFunctionRequest(appClientId, appAccessToken.access_token, {
+      name: extension.extension_name,
+      namespace: NAMESPACE,
+      source_code: sourceCodePath,
+      file: extension.distPath
+    });
+
+    if (res?.code === 'SUCCESS') {
+      return extractFunctionResult(res);
+    }
+
+    throw new Error(res?.message || 'create function extension failed');
+  }
+}
+
+module.exports = upsertFunction;