shoplazza-cli 1.1.2 → 2.0.0

package/lib/checkout/api.js

@@ -1,164 +0,0 @@
-const Axios = require('axios');
-const path = require('path');
-const fs = require('fs');
-const FormData = require('form-data');
-const loading = require('loading-cli');
-const { openAipVersion } = require('./config');
-const { isDebug, consoleWarn } = require('../utils/console');
-const { getProjectConfig } = require('./util');
-const chalk = require('chalk');
-const { useOss } = require('../oss');
-
-const FILE_SIGN_URL = '/checkout_extensions/file/sign';
-const CREATE_URL = '/checkout_extensions/create';
-const COMMIT_URL = '/checkout_extensions/commit';
-const LIST_URL = '/checkout_extensions/list';
-const VERSION_LIST_URL = '/checkout_extensions/version/list';
-const DEPLOY_URL = '/checkout_extensions/deploy';
-const UNDEPLOY_URL = '/checkout_extensions/undeploy';
-const PREVIEW_URL = '/checkout_extensions/preview';
-
-let configJson = undefined;
-let uploadOss = null;
-
-const request = new Axios.create();
-
-request.interceptors.request.use((config) => {
-  if (config.data instanceof FormData) {
-    Object.assign(config.headers, config.data.getHeaders());
-  }
-  if (!configJson) {
-    configJson = getProjectConfig();
-  }
-  config.headers['Access-Token'] = configJson.token;
-  if (!config.url.startsWith('http')) {
-    config.url = path.join(configJson.store, openAipVersion, config.url);
-    // TODO 这里需要处理一下，使用 URL 对象
-    
-  }
-
-  if (isDebug()) {
-    console.log(`\n==> ${config.method}: ${config.url}`);
-  }
-  return config;
-});
-
-const errorMapping = {
-  INVALID_ARGUMENT: 'Invalid argument',
-  PERMISSION_DENIED: 'Permission denied',
-  INTERNAL_ERROR: 'Internal error'
-};
-const handleResponseError = (response) => {
-  const errorMsg = errorMapping[response.data?.message];
-  if (errorMsg) {
-    throw `${errorMsg} at ${response.config.url}`;
-  }
-};
-
-request.interceptors.response.use(
-  (response) => {
-    if (isDebug()) {
-      console.log(`\n<== ${response.status}: ${response.config.url}`);
-    }
-    handleResponseError(response);
-    return response;
-  },
-  (error) => {
-    if (isDebug()) {
-      console.log(`\n<== error ${error.response.status}: ${error.response.config.url}`);
-    }
-    if (error.response?.status == 403) {
-      return Promise.reject(new Error('Token permission failure'));
-    }
-    return Promise.reject(error);
-  }
-);
-
-async function uploadFile(dirPath, file) {
-  if (!uploadOss) {
-    uploadOss = useOss(
-      configJson.token,
-      new URL(configJson.store).hostname,
-      `✗ No store found. Please check your "extension.config.js" file.`
-    ).uploadOss;
-  }
-  return uploadOss(`${dirPath}/${file}`);
-}
-async function uploadDir(dirPath, files) {
-  return Promise.all(
-    files.map((file) => {
-      return uploadOss(`${dirPath}/${file}`);
-    })
-  );
-}
-
-module.exports = {
-  uploadDir,
-  uploadFile,
-  getExtensionList: async (params) => {
-    const load = loading('Fetch extension list').start();
-    try {
-      const res = await request(`${LIST_URL}`, {
-        params
-      });
-      load.succeed('Successfully fetched the extension list.');
-      return res;
-    } catch (error) {
-      load.fail('Failed to fetch the extension list.');
-      throw error;
-    }
-  },
-  getVersionList: async (params) => {
-    const load = loading('Fetch version list').start();
-    try {
-      const res = await request(`${VERSION_LIST_URL}`, {
-        params
-      });
-      load.succeed('Successfully fetched the version list.');
-      return res;
-    } catch (error) {
-      load.fail('Failed to fetch the version list.');
-      throw error;
-    }
-  },
-  pushExtension: async (data, isFirstPush = false) => {
-    data = {
-      extension: {
-        ...data
-      }
-    };
-    const res = await request({ url: isFirstPush ? CREATE_URL : COMMIT_URL, method: 'POST', data });
-    if (res.data?.status === 3 && res.data?.message === 'INVALID_VERSION') {
-      throw 'During repeated pushes, the version number must be greater than the previous version number.';
-    }
-    return res;
-  },
-  deployExtension: async (data) => {
-    data = {
-      extension: {
-        ...data
-      }
-    };
-    return request({ url: DEPLOY_URL, method: 'POST', data });
-  },
-  undeployExtension: async (data) => {
-    data = {
-      extension: {
-        ...data
-      }
-    };
-    return request({ url: UNDEPLOY_URL, method: 'POST', data });
-  },
-  previewExtension: async (data) => {
-    data = {
-      extension: {
-        ...data
-      }
-    };
-    const res = await request({ url: PREVIEW_URL, method: 'POST', data });
-    if (res.data?.status === 14 && res.data?.message === 'ITEM_UNAVAILABLE') {
-      throw 'Failed to generate a preview URL because your store currently has no available items.';
-    }
-    return res;
-  }
-};

package/lib/checkout/build/plugin/vite-plugin-transform-extension-html.js

@@ -1,207 +0,0 @@
-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/checkout/build/vite.config.js

@@ -1,34 +0,0 @@
-const { cwd } = require('process');
-const { vitePluginAddExtensionId } = require('./plugin/vite-plugin-add-extension-id');
-const { vitePluginTransformExtensionHtml } = require('./plugin/vite-plugin-transform-extension-html');
-const { getDistPath } = require('../util');
-
-// https://vitejs.dev/config/
-module.exports = {
-  viteConfig: (pageEntry) => {
-    return {
-      plugins: [vitePluginTransformExtensionHtml(), vitePluginAddExtensionId()],
-      base: '/',
-      root: cwd(),
-      build: {
-        minify: false,
-        emptyOutDir: false,
-        copyPublicDir: false,
-        rollupOptions: {
-          input: pageEntry,
-          output: {
-            entryFileNames: '[name].[hash].js',
-            chunkFileNames: '[name].[hash].js',
-            assetFileNames: '[name].[hash].[ext]',
-            compact: true,
-            inlineDynamicImports: false,
-            dir: getDistPath()
-          },
-          watch: {
-            include: './extensions'
-          }
-        }
-      }
-    };
-  }
-};

package/lib/checkout/build.js

@@ -1,38 +0,0 @@
-const { consoleError, consoleBlue } = require('../utils/console');
-const { build } = require('vite');
-const { viteConfig } = require('./build/vite.config');
-const { getExtensionInfo, getDistPath } = require('./util');
-const path = require('path');
-const fs = require('fs');
-
-async function viteBuild(command) {
-  try {
-    require('./version');
-    const { id, path: extensionPath } = getExtensionInfo(command.id);
-    const pageEntry = {
-      [id]: path.join(extensionPath, 'src', 'index.js')
-    };
-    if (!fs.existsSync(getDistPath())) {
-      fs.mkdirSync(getDistPath());
-    }
-    fs.readdirSync(getDistPath()).forEach((fname) => {
-      if (fname.includes(id)) {
-        fs.rmSync(path.join(getDistPath(), fname));
-      }
-    });
-    await build(viteConfig(pageEntry));
-  } catch (err) {
-    throw 'build_error: ' + err;
-  }
-}
-
-async function cliBuild(command) {
-  try {
-    await viteBuild(command);
-  } catch (err) {}
-}
-
-module.exports = {
-  cliBuild,
-  viteBuild
-};

package/lib/checkout/config.js

@@ -1,97 +0,0 @@
-module.exports = {
-  cwd: process.cwd(),
-  openAipVersion: '/openapi',
-  defaultExtensionDir: 'extensions',
-  configFile: 'extension.json',
-  buildDir: 'dist',
-  package: 'package.json',
-  questions: commands => {
-    const { store, token, theme } = commands;
-    return require('inquirer').prompt([
-      {
-        name: 'store',
-        type: 'input',
-        default: store,
-        message: 'Please enter your store（Eg: https://developer.myshoplaza.com）',
-        when: () => {
-          if (!store) return true;
-          try {
-            new URL(store);
-          } catch (e) {
-            return 'Incorrect store'
-          }
-          return false;
-        },
-        validate: text => {
-          if (!text) return false;
-          try {
-            new URL(text);
-          } catch (e) {
-            return 'Incorrect store'
-          }
-          return true;
-        }
-      },
-      {
-        name: 'token',
-        type: 'input',
-        default: token,
-        when: !token,
-        message: 'Please enter your token（Private app token）',
-        validate: text => !!text
-      }
-    ]);
-  },
-  pullQuestion: () => {
-    return require('inquirer').prompt([
-      {
-        type: 'list',
-        name: 'pullType',
-        message: 'Choose pull type: ',
-        default: 'extension',
-        prefix: '*',
-        choices: [
-          {
-            name: 'Extension',
-            value: 'extension'
-          },
-          {
-            name: 'Fields',
-            value: 'fields',
-          },
-          // TODO:
-          // {
-          //   name: 'Source',
-          //   value: 'source'
-          // }
-        ]
-      }
-    ]);
-  },
-  outputDirPathQuestion: (commands = {}) => {
-    const outputDirPath = process.env.OUTPUT_DIR_PATH || commands.outputDirPath;
-    return require('inquirer').prompt([
-      {
-        type: 'input',
-        name: 'outputDirPath',
-        message: 'Please enter extension output directory relative path(Eg: ./src/xxx ): ',
-        default: outputDirPath || './dist/chick-extension',
-        when: !outputDirPath,
-        validate: text => !!text
-      }
-    ]);
-  },
-  dirPathQuestion: (commands = {}) => {
-    const dirPath = process.env.DIR_PATH || commands.dirPath;
-    return require('inquirer').prompt([
-      {
-        type: 'input',
-        name: 'dirPath',
-        message: 'Please enter extension directory relative path(Eg: ./src/xxx ): ',
-        default: dirPath || './extensions',
-        when: !dirPath,
-        validate: text => !!text
-      }
-    ]);
-  }
-};

package/lib/checkout/create.js

@@ -1,132 +0,0 @@
-const { consoleError, consoleSuccess } = require('../utils/console');
-const path = require('path');
-const fs = require('fs');
-const inquirer = require('inquirer');
-const { copy } = require('./util');
-
-const cwd = process.cwd();
-
-const templateDir = path.resolve(__dirname, './template');
-
-const renameFiles = {
-  _gitignore: '.gitignore'
-};
-
-const extensionNamePromptConfig = {
-  type: 'input',
-  name: 'extensionName',
-  message: 'Enter the extension name:',
-  prefix: '*'
-};
-
-async function promptWhenAddExtension(before = []) {
-  return inquirer.prompt([
-    ...before,
-    {
-      type: 'input',
-      name: 'store',
-      message: 'Enter your store URL(example: https://xxx.myshoplaza.com/):',
-      prefix: '*'
-    },
-    {
-      type: 'input',
-      name: 'token',
-      message: 'Enter the store\'s token:',
-      prefix: '*'
-    },
-    extensionNamePromptConfig
-  ]);
-}
-
-/**
- * 使用cli创建一个项目
- * @param {} command 项目名
- * @returns
- */
-async function createProject(command) {
-  const { projectName, extensionName, store, token } = await promptWhenAddExtension([
-    {
-      type: 'input',
-      name: 'projectName',
-      message: 'Please input your project name:',
-      prefix: '*'
-    }
-  ]);
-  const projectDir = projectName.replace(/\/+$/g, '');
-  const root = path.join(cwd, projectDir);
-  if (fs.existsSync(root)) {
-    consoleError(`the directory '${projectDir}' is exist.`);
-    return;
-  }
-  if (!extensionName.trim()) {
-    consoleError('extension id is required');
-    return;
-  }
-  fs.mkdirSync(root, { recursive: true });
-
-  const write = (file, content) => {
-    const targetPath = path.join(root, renameFiles[file] ?? file);
-    if (content) {
-      fs.writeFileSync(targetPath, content);
-    } else {
-      copy(path.join(templateDir, file), targetPath);
-    }
-  };
-
-  const files = fs.readdirSync(templateDir);
-  for (const file of files.filter((f) => !['package.json'].includes(f))) {
-    write(file);
-  }
-
-  let projectConfigContent = fs.readFileSync(path.join(templateDir, 'extension.config.js'), 'utf-8');
-  projectConfigContent = projectConfigContent.replace('{store}', store).replace('{token}', token);
-  write('extension.config.js', projectConfigContent);
-
-  const pkg = JSON.parse(fs.readFileSync(path.join(templateDir, `package.json`), 'utf-8'));
-  pkg.name = projectDir;
-  write('package.json', JSON.stringify(pkg, null, 2) + '\n');
-
-  fs.renameSync(path.join(root, 'extensions/extension-template'), path.join(root, `extensions/${extensionName}`));
-
-  const extensionConfig = JSON.parse(
-    fs.readFileSync(path.join(path.resolve(root, `extensions/${extensionName}`), `extension.json`), 'utf-8')
-  );
-  extensionConfig.extensionName = extensionName;
-  write(`extensions/${extensionName}/extension.json`, JSON.stringify(extensionConfig, null, 2) + '\n');
-  consoleSuccess(`Successfully created extension project '${projectName}'.`);
-}
-
-/**
- * 使用cli在现有项目中新增一个 extension
- */
-async function createExtension(command) {
-  const { extensionName } = await inquirer.prompt([extensionNamePromptConfig]);
-  const extensionsDir = path.join(cwd, 'extensions');
-  if (!fs.existsSync(extensionsDir)) {
-    consoleError('Please check current dir is a extension project');
-    return;
-  }
-
-  const targetDir = path.join(extensionsDir, extensionName);
-  if (fs.existsSync(targetDir)) {
-    consoleError(`This '${extensionName}' extension already exists.`);
-    return;
-  }
-  fs.mkdirSync(targetDir);
-
-  const extensionTemplateDir = path.join(templateDir, 'extensions', 'extension-template');
-  const files = fs.readdirSync(extensionTemplateDir);
-  for (const file of files.filter((f) => f !== 'extension.json')) {
-    copy(path.join(extensionTemplateDir, file), path.join(targetDir, file));
-  }
-
-  const extensionConfig = JSON.parse(fs.readFileSync(path.join(extensionTemplateDir, `extension.json`), 'utf-8'));
-  extensionConfig.extensionName = extensionName;
-  fs.writeFileSync(path.join(targetDir, 'extension.json'), JSON.stringify(extensionConfig, null, 2) + '\n');
-  consoleSuccess(`Successfully created extension '${extensionName}'.`);
-}
-
-module.exports = {
-  createProject,
-  createExtension
-};

package/lib/checkout/delete.js

@@ -1,26 +0,0 @@
-const api = require('./api');
-const loading = require('loading-cli');
-const { verifyConfig } = require('./verify');
-const { getExtensionInfo, getExtensionConfig } = require('./util');
-
-module.exports = async (commands = {}) => {
-  await verifyConfig(commands);
-  const info = getExtensionInfo(commands.id);
-  const config = getExtensionConfig(commands.id);
-  const deleteLoading = loading(`Delete the extension '${info.id}'.`).start();
-  await Promise.all([
-    api.deleteExtension({
-      extension_id: info.id,
-      version: config.version
-    })
-  ])
-    .then(() => {
-      deleteLoading.succeed(`Delete the extension '${info.id}' succeed.`);
-    })
-    .catch(() => {
-      deleteLoading.fail(`Delete the extension '${info.id}' failed.`).fail();
-    })
-    .finally(() => {
-      deleteLoading.stop();
-    });
-};