shoplazza-cli 1.0.6 → 1.0.7

package/bin/shoplazza

@@ -10,7 +10,8 @@ const report = require('../lib/report');
 require('../lib/tracing');
 
 const { makeCheckoutCommand } = require('../lib/checkout');
-const { initThemeAppCommand } = require('../lib/app');
+
+const { generateExtension, deployExtension, publishExtension, buildExtension, retry } = require('../lib/app');
 
 Sentry.init({
   dsn: 'https://89964605acaf4db8839f2d5237396d6c@sentry.shoplazza.com/730',
@@ -112,11 +113,21 @@ theme
   .option('-t, --theme <theme>', 'The ID of the theme that you want to delete.')
   .action(require('../lib/commands/theme/delete'));
 
+const app = program.command('app').description('Shoplazza app extensions cli');
+
+app.command('generate').command('extension').description('Generate your extension').action(generateExtension);
+app.command('deploy').command('extension').description('Deploy your extension to cdn').action(deployExtension);
+app.command('publish').command('extension').description('Publish your extension').action(publishExtension);
+app.command('build').description('Build your extension').action(buildExtension);
+app
+  .command('retry')
+  .description('Retry to do some tasks.')
+  .option('-p, --partner', 'Retry get and choose your partner list.')
+  .option('-a, --app', 'Retry get and choose your app list.')
+  .action(retry);
 
 // checkout cli
 makeCheckoutCommand(program);
-// theme app cli
-initThemeAppCommand(program);
 
 program.parse(process.argv);
 !program.args.length && program.help();

package/lib/app/commands/build.js

@@ -1,87 +1,66 @@
 const chalk = require('chalk');
-const inquirer = require('inquirer');
+const ora = require('ora');
+const fs = require('fs-extra');
 const path = require('path');
-const { getThemeAppConfig, compareVersions } = require('../utils');
-const { getThemeAppVersionList, toCreateThemeAppVersion } = require('../api/api');
 
-async function createNewVersion(appId, version, description) {
-  const themeAppPath = path.resolve(WORKSPACE_PATH, 'theme-app');
-  const { zipPath, zipName } = await compress(themeAppPath);
-  const zipOssUrl = await uploadOss(zipPath, zipName);
-  const taskId = await toCreateThemeAppVersion({
-    extension_id: appId,
-    version,
-    description,
-    resource_url: zipOssUrl
-  });
-  while (true) {
-    const res = await getTaskStatus({ taskId });
-    if (res.data?.task?.state === 1) {
-      console.log(chalk.green(`[SUCCESS] Theme app pushed successfully.`));
-      break;
-    } else if (res.data?.task?.state === 2) {
-      console.error(chalk.red(`[ERROR] Theme app push failed: ${res.data?.task?.error_message}`));
-      break;
-    } else {
-      console.log(chalk.yellow(`[WAITING] Theme app push in progress...`));
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+const { zipTheme } = require('../../utils');
+const { line, done } = require('../log');
+const { buildThemeAssets } = require('../extensions/theme-app');
+
+const isFileExist = (path) => {
+  return fs.existsSync(path);
+};
+
+const clearManifest = async () => {
+  try {
+    if (isFileExist('./assets-manifest.json') && isFileExist('./assets')) {
+      const mainfest = JSON.parse(fs.readFileSync('./assets-manifest.json', { encoding: 'utf-8' }));
+      await Promise.all(
+        Object.values(mainfest).map((path) => {
+          if (isFileExist(path)) {
+            return fs.unlink(path);
+          }
+          return Promise.resolve(true);
+        })
+      );
+      await fs.unlink('./assets-manifest.json');
     }
+    return true;
+  } catch (e) {
+    console.log(e);
   }
-}
-
-/**
- * 交互式命令行
- */
-async function usePrompt() {
-  const versionList = await getThemeAppVersionList();
-  const latestVersion = versionList[versionList.length - 1];
+};
 
-  console.log(
-    chalk.cyanBright(`\n🔍 Latest version: `) +
-      chalk.yellow(`${latestVersion.version} `) +
-      chalk.white(`(${latestVersion.description})`) +
-      chalk.gray(` [Released on: ${latestVersion.date}]`)
-  );
+const getZipName = () => {
+  return path.basename(process.cwd());
+};
 
-  return inquirer.prompt([
-    {
-      type: 'input',
-      name: 'newVersion',
-      message: 'Enter the new version number:',
-      validate: (newVersion) => {
-        if (!/^[0-9]+\.[0-9]+\.[0-9]+$/.test(newVersion)) {
-          return chalk.red('❌ Version must follow the format X.Y.Z (e.g., 1.0.0).');
-        }
-        if (compareVersions(newVersion, latestVersion.version) !== 1) {
-          return chalk.red('❌ Version must be greater than the latest version.');
-        }
-        return true;
-      }
-    },
-    {
-      type: 'input',
-      name: 'description',
-      message: 'Enter the description for this version:',
-      validate: (description) => {
-        if (!description.trim()) {
-          return chalk.red('❌ Description cannot be empty.');
-        }
-        return true;
-      }
-    }
-  ]);
-}
+const generateZip = async (name) => {
+  const zipPath = `${process.cwd()}/${name}.zip`;
+  isFileExist(zipPath) && (await fs.unlink(zipPath));
+  zipTheme(process.cwd(), name);
+};
 
-async function build() {
+const zipApp = async () => {
+  const spinner = ora(chalk.cyan('Building your app and generate zip package ...')).start();
   try {
-    const { appId } = await getThemeAppConfig();
-    const { newVersion, description } = await usePrompt();
-    await createNewVersion(appId, newVersion, description);
-  } catch (error) {
-    console.error(chalk.red(`[ERROR IN BUILD] ${error.message}`));
+    const zipName = getZipName();
+    await generateZip(zipName);
+    spinner.succeed(chalk.cyan(`Success to build your app and generate zip package: ${chalk.green(`${zipName}.zip`)}`));
+    return true;
+  } catch (e) {
+    spinner.fail(e.message);
   }
-}
+};
+
+const build = async () => {
+  line();
+  (await clearManifest()) && (await buildThemeAssets('./assets')) && (await zipApp());
+  done();
+  line();
+};
 
 module.exports = {
-  build
+  build,
+  getZipName
 };

package/lib/app/commands/deploy.js

@@ -1,47 +1,218 @@
-const inquirer = require('inquirer');
-const chalk = require('chalk');
+const axios = require('axios');
 const ora = require('ora');
-const { getThemeAppConfig } = require('../utils');
-const { getThemeAppVersionList, toDeployThemeApp } = require('../api/api');
-
-// 调用后端 API 进行部署
-async function deployVersion(appId, version) {
-  // await new Promise((resolve) => setTimeout(resolve, 2000));
-  await toDeployThemeApp({
-    extension_id: appId,
-    version,
-    type: 'enable'
-  });
-  console.log(chalk.green(`Version ${version} has been deployed successfully.`));
-}
-
-async function usePrompt(versionList) {
-  const choices = versionList.map((v) => ({
-    name: `${v.version} (${v.date}) - ${v.description}`,
-    value: v.version
-  }));
-  return inquirer.prompt([
-    {
-      type: 'list',
-      name: 'selectedVersion',
-      message: 'Select a version to deploy:',
-      choices
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const SparkMD5 = require('spark-md5');
+const FormData = require('form-data');
+const path = require('path');
+
+const { PARNTER_URL } = require('../constants');
+const { getValue, PARTNER_KEYS, getApp, set } = require('../db/partner');
+const { getZipName } = require('./build');
+const { inputVersion } = require('../inquirers/version');
+const { line, done } = require('../log');
+
+const getZipPath = () => {
+  const spinner = ora(chalk.cyan('Finding your built zip ...')).start();
+  try {
+    const zipName = getZipName();
+    const filename = fs.readdirSync(process.cwd()).find((name) => {
+      const extname = path.extname(name).replace('.', '');
+      return extname === 'zip' && name.startsWith(zipName);
+    });
+
+    if (!filename) {
+      throw new Error('not zip');
     }
-  ]);
-}
 
-async function deploy() {
+    const fileInfo = fs.statSync(`${process.cwd()}/${filename}`);
+
+    spinner.succeed(
+      chalk.cyan(
+        `Success to find your zip: ${chalk.green(`${filename} ${(fileInfo.size / (1024 * 1024)).toFixed(2)}M`)}`
+      )
+    );
+    return path.resolve(process.cwd(), filename);
+  } catch (e) {
+    spinner.fail(chalk.red('Failed to find your zip, be sure you have built app in root dir!'));
+  }
+};
+
+const getBufferAndMd5 = async (filePath) => {
+  const spinner = ora(chalk.cyan('Begin to read zip and generate md5 code ...')).start();
+
+  try {
+    return await new Promise((resolve, reject) => {
+      const spark = new SparkMD5.ArrayBuffer();
+      let buffers = [];
+
+      const rs = fs.createReadStream(filePath, { autoClose: true });
+      rs.on('data', (data) => {
+        buffers.push(data);
+        spark.append(data);
+      });
+
+      rs.on('end', () => {
+        const md5 = spark.end();
+        const completedBuffer = Buffer.concat(buffers);
+        spinner.succeed(chalk.cyan('Success to analyse zip'));
+        resolve([completedBuffer, md5 + '.zip']);
+      });
+
+      rs.on('error', (err) => {
+        reject(err);
+      });
+    });
+  } catch (e) {
+    spinner.fail(chalk.red('Failed to analyse zip, please try again!'));
+  }
+};
+
+const getSign = async () => {
+  const spinner = ora(chalk.cyan('Waiting get file sign ...')).start();
+
   try {
-    const { appId } = await getThemeAppConfig();
-    const spinner = ora('Fetching version list...').start();
-    const versionList = await getThemeAppVersionList();
-    spinner.succeed('Version list loaded.');
-    const { selectedVersion } = await usePrompt(versionList);
-    await deployVersion(appId, selectedVersion);
-  } catch (error) {
-    console.error(chalk.red(`[ERROR IN DEPLOY] ${error.message}`));
+    const app = getApp();
+    const partnerId = getValue(PARTNER_KEYS.PARTNER_ID);
+    const sessionId = getValue(PARTNER_KEYS.SESSION_ID);
+
+    const url = `${PARNTER_URL}/api/partner/apps/${app.uid}/theme_extensions/file/signv2`;
+    const res = await axios.get(url, {
+      headers: {
+        Cookie: `awesomev2=${sessionId}`,
+        'x-shoplazza-partner-id': partnerId
+      }
+    });
+    spinner.succeed(chalk.cyan('Success to get file sign'));
+    return res.data;
+  } catch (e) {
+    spinner.fail(chalk.red(e.message || e));
   }
-}
+};
+
+const deployOss = async () => {
+  const path = getZipPath();
+  if (path) {
+    const [buffer, md5] = await getBufferAndMd5(path);
+    const signData = await getSign();
+    if (!signData) {
+      return;
+    }
+
+    const spinner = ora(chalk.cyan('Deploying your zip to cdn ...')).start();
+
+    try {
+      const formData = new FormData();
+      formData.append('policy', signData.policy);
+      formData.append('OSSAccessKeyId', signData.access_id);
+      formData.append('success_action_status', 200);
+      formData.append('signature', signData.sign);
+      formData.append('x-oss-forbid-overwrite', 'true');
+      formData.append('key', md5);
+      formData.append('file', buffer);
+
+      const url = `https:${signData.write_host}/`;
+      const res = await axios.post(url, formData, {
+        global: true,
+        maxContentLength: 100000000,
+        maxBodyLength: 1000000000
+      });
+
+      if (res.status !== 200) {
+        throw new Error(`${res.status} ${resstatusText}`);
+      }
+      spinner.succeed();
+      return md5;
+    } catch (e) {
+      // 409 repeat filename
+      if (e?.response?.status === 409) {
+        spinner.succeed();
+        return md5;
+      }
+      spinner.fail();
+      console.log(chalk.red(e.message || e));
+    }
+  }
+};
+
+const deployPartner = async () => {
+  const md5 = await deployOss();
+  if (!md5) {
+    return;
+  }
+
+  const spinner = ora(chalk.cyan('Deploying your zip to PARTNER ...')).start();
+  try {
+    const app = getApp();
+    if (!app) {
+      spinner.fail(chalk.red('Please choose your partner first!'));
+      return;
+    }
+
+    const partnerId = getValue(PARTNER_KEYS.PARTNER_ID);
+    const url = `${PARNTER_URL}/api/partner/apps/${app.uid}/theme_extensions`;
+    const res = await axios.put(
+      url,
+      {
+        title: getZipName(),
+        name: getZipName(),
+        file_name: md5
+      },
+      {
+        headers: {
+          cookie: `awesomev2=${getValue(PARTNER_KEYS.SESSION_ID)};`,
+          'x-shoplazza-partner-id': partnerId
+        }
+      }
+    );
+
+    set({ [PARTNER_KEYS.EXTENSION_ID]: res.data.extension_id });
+    spinner.succeed();
+    return true;
+  } catch (e) {
+    spinner.fail();
+    console.log(e.message || e);
+    console.log(chalk.red(JSON.stringify(e.response.data)));
+  }
+};
+
+const createVersion = async (version) => {
+  const spinner = ora(chalk.cyan('Creating your version task ...')).start();
+
+  try {
+    const app = getApp();
+    const extensionId = getValue(PARTNER_KEYS.EXTENSION_ID);
+    const partnerId = getValue(PARTNER_KEYS.PARTNER_ID);
+
+    const url = `${PARNTER_URL}/api/partner/apps/${app.uid}/theme_extensions/${extensionId}/version_tasks`;
+    await axios.post(
+      url,
+      {
+        version
+      },
+      {
+        headers: {
+          cookie: `awesomev2=${getValue(PARTNER_KEYS.SESSION_ID)};`,
+          'x-shoplazza-partner-id': partnerId
+        }
+      }
+    );
+    spinner.succeed();
+    return true;
+  } catch (e) {
+    spinner.fail();
+    console.log(chalk.red(e.message || e));
+    console.log(chalk.red(JSON.stringify(e.response?.data)));
+  }
+};
+
+const deploy = async () => {
+  line();
+  ora(chalk.cyan('Deploy Begin')).succeed();
+  let version;
+  (await deployPartner()) && (version = await inputVersion()) && (await createVersion(version)) && done();
+  line();
+};
 
 module.exports = {
   deploy

package/lib/app/commands/generate.js

@@ -0,0 +1,50 @@
+const inquirer = require('inquirer');
+const { set, PARTNER_KEYS } = require('../db/partner');
+const { themeAppHandler, checkoutUIHandler } = require('../extensions');
+const { line } = require('../log');
+
+const EXTENSION_TYPES = {
+  CHECKOUT_UI: 'checkout_ui',
+  THEME_APP: 'theme_app'
+};
+
+const generate = async () => {
+  line();
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'extensionType',
+      message: 'Choose your extension type ↓',
+      default: EXTENSION_TYPES.THEME_APP,
+      prefix: '*',
+      choices: [
+        {
+          name: 'Theme App Extension',
+          value: EXTENSION_TYPES.THEME_APP
+        }
+      ]
+    },
+    {
+      type: 'input',
+      name: 'extensionName',
+      message: 'Input your extesion name: ',
+      default: 'my-extension',
+      prefix: '*'
+    }
+  ]);
+  line();
+
+  set({ [PARTNER_KEYS.EXTENSION_TYPE]: answer.extensionType });
+
+  if (answer.extensionType === EXTENSION_TYPES.THEME_APP) {
+    await themeAppHandler(answer.extensionName);
+  } else if (answer.extensionType === EXTENSION_TYPES.CHECKOUT_UI) {
+    await checkoutUIHandler(answer.extensionName);
+  }
+
+  line();
+};
+
+module.exports = {
+  generate
+};

package/lib/app/commands/publish.js

@@ -0,0 +1,52 @@
+const { default: axios } = require('axios');
+const { selectVersion } = require('../inquirers/version');
+const { PARNTER_URL } = require('../constants');
+const { get, getValue, PARTNER_KEYS } = require('../db/partner');
+const ora = require('ora');
+const chalk = require('chalk');
+const { getZipName } = require('./build');
+const { done, line } = require('../log');
+
+const publishVersion = async ({ version, appId, versionId, extensionId }) => {
+  const spinner = ora(chalk.cyan('Waiting publish ...'));
+
+  try {
+    const partnerId = getValue(PARTNER_KEYS.PARTNER_ID);
+    if (!partnerId) {
+      spinner.fail(chalk.red('Please choose a partner first!'));
+      return;
+    }
+
+    const url = `${PARNTER_URL}/api/partner/apps/${appId}/theme_extensions/${extensionId}/publications`;
+    await axios.post(
+      url,
+      {
+        name: getZipName(),
+        version_id: versionId,
+        type: 'enable'
+      },
+      {
+        headers: {
+          cookie: `awesomev2=${getValue(PARTNER_KEYS.SESSION_ID)};`,
+          'x-shoplazza-partner-id': partnerId
+        }
+      }
+    );
+
+    spinner.succeed();
+    return true;
+  } catch (e) {
+    spinner.fail(e.message || e);
+  }
+};
+
+const publish = async () => {
+  const versionData = await selectVersion();
+  await publishVersion(versionData);
+  done();
+  line();
+};
+
+module.exports = {
+  publish
+};

package/lib/app/extensions/index.js

@@ -0,0 +1,13 @@
+const { generateThemeDirectory } = require('./theme-app');
+const { done } = require('../log');
+
+const themeAppHandler = async (dirname = './') => {
+  (await generateThemeDirectory(dirname)) && done();
+};
+
+const checkoutUIHandler = async () => {};
+
+module.exports = {
+  themeAppHandler,
+  checkoutUIHandler
+};

package/lib/app/extensions/theme-app.js

@@ -0,0 +1,103 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs-extra');
+const glob = require('glob');
+const repo = require('download-git-repo');
+const CleanCSS = require('clean-css');
+const UglifyJS = require('uglify-js');
+
+const crypto = require('crypto');
+const path = require('path');
+const { line } = require('../log');
+
+const rev = (input) => crypto.createHash('md5').update(input).digest('hex').slice(0, 8);
+const cleanCSS = new CleanCSS({
+  advanced: false,
+  aggressiveMerging: false
+});
+
+const generateThemeDirectory = async (dirname = './') => {
+  const spinner = ora(chalk.cyan(`Waiting generate your theme app project...`)).start();
+  try {
+    await new Promise((resolve, reject) => {
+      repo('Shoplazza/theme-extension-template', dirname, {}, (err) => {
+        if (err) {
+          reject(JSON.stringify(err));
+        } else {
+          resolve(true);
+        }
+      });
+    });
+
+    spinner.succeed(chalk.cyan(`Generate app successfully`));
+    return true;
+  } catch (e) {
+    spinner.fail();
+    console.log(chalk.red(e));
+  }
+};
+
+const buildThemeAssets = async (outputDir = './dist', pathPrefix = '.') => {
+  line();
+  ora(chalk.cyan(`Prepare Build assets ...`)).succeed();
+
+  const manifest = {};
+
+  // build assets css
+  const spinner = ora(chalk.cyan(`Build assets ...`)).start();
+  try {
+    const cssPathnames = glob.sync('./assets/*.css');
+    const jsPathnames = glob.sync('./assets/*.js');
+
+    const pathnames = [...cssPathnames, ...jsPathnames];
+    for (const pathname of pathnames) {
+      const filename = path.basename(pathname);
+      const extname = path.extname(pathname);
+      const fileContent = fs.readFileSync(pathname, 'utf8');
+      const hash = rev(fileContent);
+
+      let minified = '';
+      let filenameWithHash = '';
+      if (extname.includes('css')) {
+        minified = cleanCSS.minify(fileContent);
+        if (minified.errors.length) {
+          spinner.fail(minified.errors);
+          process.exit(-1);
+        }
+        filenameWithHash = `${filename.split('.')[0]}-${hash}.css`;
+        const assetsPath = `${outputDir}/${filenameWithHash}`;
+        fs.ensureFileSync(assetsPath);
+        fs.writeFileSync(assetsPath, minified.styles);
+      } else if (extname.includes('js')) {
+        minified = UglifyJS.minify(fileContent);
+        if (minified.error) {
+          log.error(minified.error);
+          process.exit(-1);
+        }
+        filenameWithHash = `${filename.split('.')[0]}-${hash}.js`;
+        const assetsPath = `${outputDir}/${filenameWithHash}`;
+        fs.ensureFileSync(assetsPath);
+        fs.writeFileSync(assetsPath, minified.code);
+      }
+
+      manifest[filename] = pathPrefix + '/assets/' + filenameWithHash;
+    }
+
+    fs.writeFileSync(`./assets-manifest.json`, JSON.stringify(manifest));
+    spinner.succeed(chalk.cyan(`Build assets done`));
+    return true;
+  } catch (e) {
+    spinner.fail(chalk.red(e.message));
+  }
+
+  // build assets js
+  const jsSpinner = ora(chalk.cyan(`Build js ...`)).start();
+  try {
+    jsSpinner.succeed(chalk.cyan(`Build js done`));
+  } catch (e) {}
+};
+
+module.exports = {
+  generateThemeDirectory,
+  buildThemeAssets
+};