shoplazza-cli 0.0.1

package/lib/commands/theme/push.js

@@ -0,0 +1,106 @@
+const ora = require('ora');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const Sentry = require('@sentry/node');
+const fs = require('fs-extra');
+const { get } = require('../../db/user');
+const { getThemeDetail, getThemes, getDefaultThemeDetail, pushTheme, getPushTask } = require('../../openAPI/api');
+const { sleep, formatThemeList } = require('../../utils');
+const { checkAndZipThemes } = require('./package');
+const log = require('../../log');
+
+const checkPushTask = (taskId) => {
+  let maxCheckCount = 60;
+  let state = -1;
+  return new Promise(async (resolve, reject) => {
+    while (maxCheckCount--) {
+      const {
+        data: {
+          task: { status, info, message }
+        }
+      } = await getPushTask(taskId);
+      status == 0 && (await sleep(2000));
+      if (status == 1 || status == 2) {
+        state = status;
+        state == 1 && resolve(info);
+        state == 2 && reject(`Status Detection failure (2), Error message: ${message}`);
+        break;
+      }
+    }
+    state == -1 && reject('Retry timeout');
+  }).catch((error) => {
+    log.error(chalk.red(`\n✗ Failed to push theme`, error));
+    Sentry.captureException(error);
+    process.exit(-1);
+  });
+};
+
+const pushThemeFiles = async (theme) => {
+  let merchant_theme_id = '';
+  let name = '';
+  if (theme) {
+    const { data } = await getThemeDetail(theme);
+    if (!data) {
+      log.error(chalk.red(`✗ Theme ${theme} does not exist`));
+      process.exit(-1);
+    }
+    name = data.data.name;
+    merchant_theme_id = data.data.merchant_theme_id;
+  }
+
+  const { theme_name, theme_version = '', zipPath } = checkAndZipThemes();
+  const {
+    data: {
+      task: {
+        task: { id }
+      }
+    }
+  } = await pushTheme({
+    name: name || theme_name,
+    version: theme_version,
+    merchant_theme_id,
+    theme_id: theme || '',
+    zipPath
+  });
+  fs.rmSync(zipPath);
+  return checkPushTask(id);
+};
+
+const execPushTheme = async (theme) => {
+  const storeDomain = get('store_domain');
+  const spinner = ora(chalk.cyan(`Pushing theme files on ${storeDomain}`)).start();
+  const { name } = JSON.parse(await pushThemeFiles(theme));
+  spinner.stop();
+  log.info(chalk.green(`✓ The ${name} theme pushed successfully`));
+};
+
+const pushCommand = async (options) => {
+  try {
+    if (options.theme) {
+      await execPushTheme(options.theme);
+    } else {
+      const storeDomain = get('store_domain');
+      const spinner = ora(chalk.cyan(`Fetching theme lists from ${storeDomain}`)).start();
+      const [themesRes, defaultThemeRes] = await Promise.all([getThemes(), getDefaultThemeDetail()]);
+      spinner.stop();
+      const answers = await inquirer.prompt([
+        {
+          name: 'theme',
+          type: 'rawlist',
+          message: `Select a theme to push ${chalk.cyan('(Choose with ↑ ↓ ⏎)')}`,
+          choices: [
+            { name: ' Create a new unpublished theme', value: '' },
+            ...formatThemeList([defaultThemeRes.data.data, ...themesRes.data.data.themes], defaultThemeRes.data.data.id)
+          ]
+        }
+      ]);
+      await execPushTheme(answers.theme);
+    }
+  } catch (error) {
+    log.error(chalk.red(`✗ Failed to push theme`));
+    Sentry.captureException(error);
+  }
+};
+
+exports.pushCommand = pushCommand;
+exports.pushThemeFiles = pushThemeFiles;

package/lib/commands/theme/serve.js

@@ -0,0 +1,153 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+const ora = require('ora');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const Sentry = require('@sentry/node');
+const livereload = require('livereload');
+const watch = require('node-watch');
+const { get, set } = require('../../db/user');
+const { pushThemeFiles } = require('./push');
+const { getThemes, getDefaultThemeDetail, deleteFile, updateFile, addFile, getFileList } = require('../../openAPI/api');
+const log = require('../../log');
+const { THEME_DIRS } = require('../../config');
+const { getThemeFilenameTypeAndLocation, formatThemeList } = require('../../utils');
+
+const existInList = (filename, fileList) => {
+  const { type, location } = getThemeFilenameTypeAndLocation(filename);
+  return fileList[type] && fileList[type].find((item) => item.location == location);
+};
+const deleteInList = (filename, fileList) => {
+  const { type, location } = getThemeFilenameTypeAndLocation(filename);
+  fileList[type] = fileList[type].filter((i) => i.location !== location);
+};
+const addInList = (filename, fileList) => {
+  const { type, location } = getThemeFilenameTypeAndLocation(filename);
+  fileList[type].push({ location });
+};
+
+const startDevServer = async (theme) => {
+  const { data: fileList } = await getFileList(theme);
+  const server = livereload.createServer({ port: '21647', applyCSSLive: false, applyImgLive: false });
+  const watcher = watch(process.cwd(), {
+    recursive: true,
+    filter: (f, skip) => {
+      const { type } = getThemeFilenameTypeAndLocation(f);
+      return THEME_DIRS.includes(type);
+    }
+  });
+  return new Promise((resolve, reject) => {
+    watcher
+      .on('change', async (evt, filename) => {
+        try {
+          log.info(chalk.green(`[${evt}]: ${filename}`));
+          if (
+            fs.existsSync(path.join(process.cwd(), filename)) &&
+            fs.lstatSync(path.join(process.cwd(), filename)).isDirectory()
+          )
+            return; // windows change return directory always
+          if (evt == 'remove') {
+            await deleteFile(theme, filename);
+            deleteInList(filename, fileList);
+          } else if (!/\/\.\w+/.test(filename)) {
+            // path not contain .xxx hidden file/folder
+            if (existInList(filename, fileList)) {
+              await updateFile(theme, filename);
+            } else {
+              await addFile(theme, filename);
+              addInList(filename, fileList);
+              if (fs.readFileSync(filename, 'utf-8')) {
+                // addFile api not support post with content
+                await updateFile(theme, filename);
+              }
+            }
+          }
+          server.refresh();
+          log.info(chalk.cyan(`Updated, please refresh your browser, will continue listening for file changes ...`));
+        } catch (err) {
+          log.error(chalk.red(`✗ ${err.message || 'Unknown error'}`));
+        }
+      })
+      .on('error', (err) => {
+        reject(err);
+        log.error(chalk.red(`✗ Error `, err));
+        Sentry.captureException(err);
+      })
+      .on('ready', () => {
+        resolve(watcher);
+        const storeDomain = get('store_domain');
+        const url = new URL(`https://${storeDomain}`);
+        url.searchParams.set('preview_theme_id', theme);
+        log.info(
+          `Please open this URL in your browser:
+        ${chalk.green(url.href)}
+
+        Customize this theme in the Theme Editor, and use 'theme pull' to get the changes:
+        ${chalk.green(`https://${storeDomain}/admin/smart_apps/editor?theme_id=${theme}`)}`.replace(/^[^\S\n]+/gm, '')
+        );
+        log.info(`\nListening for file changes ...`);
+      });
+  });
+};
+
+module.exports = async (options) => {
+  try {
+    const storeDomain = get('store_domain');
+    if (options.theme) {
+      const spinner = ora(chalk.cyan(`Syncing theme files on ${storeDomain}`)).start();
+      const { name } = await pushThemeFiles(options.theme);
+      set({
+        theme_id: options.theme,
+        theme_name: `${name} (${options.theme})`
+      });
+      spinner.stop();
+      return startDevServer(options.theme);
+    } else {
+      const spinner = ora(chalk.cyan(`Fetching theme lists`)).start();
+      const [themesRes, defaultThemeRes] = await Promise.all([getThemes(), getDefaultThemeDetail()]);
+      spinner.stop();
+      const themeList = [defaultThemeRes.data.data, ...themesRes.data.data.themes];
+      const choices = [
+        { name: 'Create a new unpublished theme', value: '' },
+        ...formatThemeList(themeList, defaultThemeRes.data.data.id)
+      ];
+      const theme_id = get('theme_id');
+      const theme_name = get('theme_id');
+
+      if (theme_id && theme_name && themeList.find((theme) => theme.id == theme_id)) {
+        choices.unshift({ name: `Use previous selected ${theme_name}`, value: theme_id });
+      }
+
+      const answers = await inquirer.prompt([
+        {
+          name: 'theme',
+          type: 'rawlist',
+          message: `Select a theme to push ${chalk.cyan('(Choose with ↑ ↓ ⏎)')}`,
+          choices: choices
+        }
+      ]);
+
+      const syncSpinner = ora(chalk.cyan(`Syncing theme files on ${storeDomain}`)).start();
+      if (answers.theme) {
+        const themeObj = themeList.find((theme) => theme.id == answers.theme);
+        set({
+          theme_id: themeObj.id,
+          theme_name: themeObj.name
+        });
+        await pushThemeFiles(answers.theme);
+      } else {
+        const { name, theme_id } = JSON.parse(await pushThemeFiles(answers.theme));
+        set({
+          theme_id,
+          theme_name: name
+        });
+      }
+      syncSpinner.stop();
+      return startDevServer(get('theme_id'));
+    }
+  } catch (error) {
+    log.error(chalk.red(`✗ Failed to serve theme`));
+    Sentry.captureException(error);
+  }
+};

package/lib/commands/theme/share.js

@@ -0,0 +1,20 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const Sentry = require('@sentry/node');
+const log = require('../../log');
+const { getShopDetail } = require('../../openAPI/api');
+const { pushThemeFiles } = require('./push');
+
+module.exports = async () => {
+  try {
+    const { data } = await getShopDetail();
+    const spinner = ora(chalk.cyan(`Pushing theme files on ${data.shop.domain}`)).start();
+    const { name, theme_id } = JSON.parse(await pushThemeFiles());
+    spinner.stop();
+    log.info(chalk.green(`✓ The ${name} Theme pushed successfully`));
+    log.info(`Share your theme preview:\n${chalk.cyan(`https://${data.shop.domain}?preview_theme_id=${theme_id}`)}`);
+  } catch (error) {
+    log.error(chalk.red(`✗ Failed to share theme`));
+    Sentry.captureException(error);
+  }
+};

package/lib/commands/version.js

@@ -0,0 +1,6 @@
+const pkg = require('../../package.json');
+const log = require('../log');
+
+module.exports = () => {
+  log.info(pkg.version);
+};

package/lib/config.js

@@ -0,0 +1,5 @@
+exports.SSO_AUTH_URL = 'https://sso.shoplazza.com';
+exports.ACCOUNT_URL = 'https://myaccount.shoplazza.com';
+exports.CLIENT_ID = '807525c9-dd77-4f4e-a738-d1e9d02c593d';
+exports.REDIRECT_URI = 'http://127.0.0.1:3456';
+exports.THEME_DIRS = ['assets', 'config', 'layout', 'locales', 'sections', 'snippets', 'templates'];

package/lib/db/__mocks__/index.js

@@ -0,0 +1,9 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+
+fs.ensureDirSync(path.join(os.homedir(), '/.tmp/shoplazza'));
+
+const db = require('better-sqlite3')(path.join(os.homedir(), '/.tmp/shoplazza/.user.db'), {});
+
+module.exports = db;

package/lib/db/__tests__/analytics.test.js

@@ -0,0 +1,19 @@
+const { hasBeenSetAnalytics, isEnabledAnalytics, setAnalyticsConfig, emptyAnalyticsData } = require('../analytics');
+jest.mock('../index');
+
+describe('db/analytics.js', () => {
+  beforeEach(() => {
+    emptyAnalyticsData();
+  });
+
+  it('get and set', () => {
+    expect(hasBeenSetAnalytics('user_id')).toBe(false);
+    expect(isEnabledAnalytics('user_id')).toBe(false);
+    setAnalyticsConfig({
+      user_id: 'user_id',
+      enabled: 0
+    });
+    expect(hasBeenSetAnalytics('user_id')).toBe(true);
+    expect(isEnabledAnalytics('user_id')).toBe(false);
+  });
+});

package/lib/db/__tests__/user.test.js

@@ -0,0 +1,20 @@
+const { get, set, empty } = require('../user');
+jest.mock('../index');
+
+describe('db/user.js', () => {
+  beforeEach(() => {
+    empty();
+  });
+
+  it('get and set', () => {
+    expect(get('access_token')).toBe(null);
+    set({
+      access_token: 'access_token',
+      session_id: 'session_id',
+      exchange_token: 'exchange_token'
+    });
+    expect(get('access_token')).toBe('access_token');
+    expect(get('session_id')).toBe('session_id');
+    expect(get('exchange_token')).toBe('exchange_token');
+  });
+});

package/lib/db/analytics.js

@@ -0,0 +1,48 @@
+const db = require('./index');
+
+const createTableIfNeeded = () => {
+  const createTable = db.prepare(`create table if not exists analytics (
+      id integer primary key AUTOINCREMENT,
+      user_id text,
+      enabled integer
+    )`);
+  createTable.run();
+};
+createTableIfNeeded();
+
+const getItem = (userId) => {
+  const stmt = db.prepare('select * from analytics where user_id = ?');
+  return stmt.get(userId);
+};
+
+const insertOrReplace = ({ user_id, enabled }) => {
+  const stmt = db.prepare(
+    `insert or replace into analytics (id, user_id, enabled) values (
+      (select id from analytics where user_id = @user_id),
+      @user_id,
+      @enabled
+    )`
+  );
+  stmt.run({ user_id, enabled });
+};
+
+const hasBeenSetAnalytics = (userId) => {
+  const item = getItem(userId);
+  return [0, 1].includes(item?.enabled);
+};
+
+const isEnabledAnalytics = (userId) => {
+  const item = getItem(userId);
+  return item?.enabled === 1;
+};
+
+const setAnalyticsConfig = (keyValueObj) => {
+  insertOrReplace(keyValueObj);
+};
+
+const emptyAnalyticsData = () => {
+  const stmt = db.prepare(`delete from analytics`);
+  stmt.run();
+};
+
+module.exports = { hasBeenSetAnalytics, isEnabledAnalytics, setAnalyticsConfig, emptyAnalyticsData };

package/lib/db/index.js

@@ -0,0 +1,9 @@
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+
+fs.ensureDirSync(path.join(os.homedir(), '/.cache/shoplazza'));
+
+const db = require('better-sqlite3')(path.join(os.homedir(), '/.cache/shoplazza/.user.db'), {});
+
+module.exports = db;

package/lib/db/user.js

@@ -0,0 +1,68 @@
+const db = require('./index');
+
+const createTableIfNeeded = () => {
+  const createTable = db.prepare(`create table if not exists user (
+      id integer primary key AUTOINCREMENT,
+      access_token  text,
+      session_id text,
+      exchange_token text,
+      theme_id  text,
+      theme_name text,
+      store_domain text,
+      user_id text
+    )`);
+  createTable.run();
+};
+createTableIfNeeded();
+
+const getUserObj = () => {
+  const stmt = db.prepare('select * from user limit 0,1;');
+  return stmt.get();
+};
+
+const insertOrReplace = ({
+  access_token = get('access_token'),
+  session_id = get('session_id'),
+  exchange_token = get('exchange_token'),
+  theme_id = get('theme_id'),
+  theme_name = get('theme_name'),
+  store_domain = get('store_domain'),
+  user_id = get('user_id')
+}) => {
+  const stmt = db.prepare(
+    `insert or replace into user (id, access_token, session_id, exchange_token, theme_id, theme_name, store_domain, user_id) values (
+      (select id from user where access_token = @access_token),
+      @access_token,
+      @session_id,
+      @exchange_token,
+      @theme_id,
+      @theme_name,
+      @store_domain,
+      @user_id
+    )`
+  );
+  stmt.run({ access_token, session_id, exchange_token, theme_id, theme_name, store_domain, user_id });
+};
+
+const emptyUserData = () => {
+  const stmt = db.prepare(`delete from user`);
+  stmt.run();
+};
+
+const get = (key) => {
+  const userObj = getUserObj();
+  if (userObj) {
+    return userObj[key];
+  }
+  return null;
+};
+
+const set = (keyValueObj) => {
+  insertOrReplace(keyValueObj);
+};
+
+const empty = () => {
+  emptyUserData();
+};
+
+module.exports = { get, set, empty };

package/lib/log.js

@@ -0,0 +1,13 @@
+const report = require('./report');
+
+module.exports = {
+  error: (...args) => {
+    console.log(...args);
+    report('cli_usage_error', {
+      args: args
+    });
+  },
+  info: (...args) => {
+    console.log(...args);
+  }
+};

package/lib/openAPI/__mocks__/index.js

@@ -0,0 +1,20 @@
+const axios = require('axios');
+
+const openAPI = axios.create({
+  baseURL: `https://developer.myshoplaza.com/openapi/2020-07`
+});
+
+openAPI.interceptors.request.use((config) => {
+  return config;
+});
+
+openAPI.interceptors.response.use(
+  function (response) {
+    return response;
+  },
+  function (error) {
+    return Promise.reject(error);
+  }
+);
+
+module.exports = openAPI;

package/lib/openAPI/api.js

@@ -0,0 +1,76 @@
+const fs = require('fs-extra');
+const FormData = require('form-data');
+const { getThemeFilenameTypeAndLocation } = require('../utils');
+const openAPI = require('./index');
+
+exports.getShopDetail = (config = {}) => {
+  return openAPI.get('/shop', config);
+};
+
+exports.getThemes = () => {
+  return openAPI.get('/themes');
+};
+
+exports.getThemeDetail = (theme) => {
+  return openAPI.get(`/themes/${theme}`);
+};
+
+exports.getDefaultThemeDetail = () => {
+  return openAPI.get(`/themes/default-theme`);
+};
+
+exports.pullTheme = (theme) => {
+  return openAPI.get(`/themes/${theme}/download`, { responseType: 'stream' });
+};
+
+exports.pushTheme = ({ zipPath, name, version, merchant_theme_id, theme_id }) => {
+  const form = new FormData();
+  form.append('file', fs.createReadStream(zipPath));
+  return openAPI.post('/themes/upload', form, {
+    headers: form.getHeaders(),
+    params: { name, version, merchant_theme_id, theme_id }
+  });
+};
+
+exports.getPushTask = (taskId) => {
+  return openAPI.get(`/themes/task/${taskId}`);
+};
+
+exports.publishTheme = (theme) => {
+  return openAPI.patch(`/themes/${theme}/publish`);
+};
+
+exports.deleteTheme = (theme) => {
+  return openAPI.delete(`/themes/${theme}`);
+};
+
+exports.getFileList = (theme) => {
+  return openAPI.get(`/themes/${theme}/doctree`);
+};
+
+exports.deleteFile = (theme, filename) => {
+  const { type, location } = getThemeFilenameTypeAndLocation(filename);
+  return openAPI.delete(`/themes/${theme}/doc`, { params: { type, location } });
+};
+
+exports.updateFile = (theme, filename) => {
+  const { type, location } = getThemeFilenameTypeAndLocation(filename);
+  return openAPI.patch(`/themes/${theme}/doc`, {
+    doc: {
+      type,
+      location,
+      content: fs.readFileSync(filename, 'utf-8')
+    }
+  });
+};
+
+exports.addFile = (theme, filename) => {
+  const { type, location } = getThemeFilenameTypeAndLocation(filename);
+  return openAPI.post(`/themes/${theme}/doc`, {
+    doc: {
+      type,
+      location,
+      content: fs.readFileSync(filename, 'utf-8')
+    }
+  });
+};

package/lib/openAPI/index.js

@@ -0,0 +1,46 @@
+const axios = require('axios');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const Sentry = require('@sentry/node');
+const { get, set } = require('../db/user');
+const { getThemeFilenameTypeAndLocation } = require('../utils');
+const { postExchangeToken } = require('../auth');
+const log = require('../log');
+
+const openAPI = axios.create({
+  baseURL: `https://${get('store_domain')}/openapi/2020-07`,
+  headers: { 'Access-Token': get('exchange_token') }
+});
+
+openAPI.interceptors.request.use((config) => {
+  if (!get('store_domain')) {
+    log.error(
+      chalk.red(
+        `\n✗ No store found. Please run ${chalk.cyan('shoplazza login --store STORE')} to login to a specific store`
+      )
+    );
+    process.exit(-1);
+  }
+  return config;
+});
+
+openAPI.interceptors.response.use(
+  function (response) {
+    return response;
+  },
+  function (error) {
+    // Token expired will return a 400 error
+    if (error?.response?.status === 400) {
+      set({
+        exchange_token: ''
+      });
+      return postExchangeToken(get('store_domain'), { ignoreLogError: error.config.ignoreLogError }).then(() => {
+        error.config.headers['Access-Token'] = get('exchange_token');
+        return openAPI(error.config);
+      });
+    }
+    return Promise.reject(error);
+  }
+);
+
+module.exports = openAPI;

package/lib/report.js

@@ -0,0 +1,37 @@
+const { get } = require('./db/user');
+const { isEnabledAnalytics } = require('./db/analytics');
+const pkg = require('../package.json');
+const axios = require('axios');
+
+const report = (eventName, properties = {}) => {
+  const user_id = get('user_id');
+  if (!isEnabledAnalytics(user_id)) return;
+  axios.post(
+    `https://r.shoplazza.com/beacon/sa.gif`,
+    `data=${encodeURIComponent(
+      Buffer.from(
+        JSON.stringify({
+          distinct_id: user_id,
+          event: eventName,
+          type: 'track',
+          _track_id: parseInt(Math.random() * (9999999999 - 999999999 + 1) + 999999999, 10),
+          properties: {
+            platform: 'shoplazza-cli',
+            cli_version: pkg.version,
+            user_id,
+            ...properties
+          }
+        })
+      ).toString('base64')
+    )}`,
+    {
+      headers: { 'content-type': 'text/plain;charset=UTF-8' },
+      params: {
+        project: 'production',
+        gzip: 0
+      }
+    }
+  );
+};
+
+module.exports = report;