shoplazza-cli 0.0.1

package/lib/auth/index.js

@@ -0,0 +1,91 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const Sentry = require('@sentry/node');
+const querystring = require('querystring');
+const { get, set, empty } = require('../db/user');
+const log = require('../log');
+const { SSO_AUTH_URL, ACCOUNT_URL, CLIENT_ID, REDIRECT_URI } = require('../config');
+
+exports.postAccessToken = async (code) => {
+  try {
+    const { data } = await axios.post(
+      `${SSO_AUTH_URL}/api/oauth/token`,
+      querystring.stringify({
+        client_id: CLIENT_ID,
+        code,
+        grant_type: 'authorization_code',
+        redirect_uri: REDIRECT_URI
+      }),
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        }
+      }
+    );
+    empty();
+    set({
+      access_token: data.access_token,
+      session_id: data.session_id
+    });
+  } catch (err) {
+    log.error(chalk.red('\n✗ Failed to post access token'));
+    process.exit(-1);
+  }
+};
+
+exports.getUserInfo = async () => {
+  try {
+    const { data } = await axios.get(`${SSO_AUTH_URL}/api/sso/current/users`, {
+      headers: {
+        Cookie: `awesomev2=${get('session_id')}`
+      }
+    });
+    const activeUser = data.users.find((user) => user.active) || data.users[0];
+    set({
+      user_id: activeUser.user_id
+    });
+  } catch (err) {
+    log.error(chalk.red('✗ Failed to get user info'));
+    process.exit(-1);
+  }
+};
+
+exports.postExchangeToken = async (storeDomain, options = {}) => {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const { data } = await axios.post(
+        `${ACCOUNT_URL}/api/accounts/store/token`,
+        {
+          user_id: get('user_id'),
+          domain: storeDomain
+        },
+        {
+          headers: {
+            Cookie: `awesomev2=${get('session_id')}`
+          }
+        }
+      );
+      set({
+        store_domain: storeDomain,
+        exchange_token: data.access_token
+      });
+      resolve();
+    } catch (err) {
+      reject(err);
+      Sentry.captureException(err);
+      empty();
+      if (!options.ignoreLogError) {
+        if (err?.response?.status === 401) {
+          log.error(chalk.red(`\n✗ You are not authorized to edit themes on ${storeDomain}.`));
+          log.info(
+            chalk.green(
+              'Check if your user is activated, has permission to edit themes at the store, and try to re-login.'
+            )
+          );
+        } else {
+          log.error(chalk.red(`\n✗ ${storeDomain} is not a valid store.`));
+        }
+      }
+    }
+  });
+};

package/lib/commands/__tests__/login.test.js

@@ -0,0 +1,77 @@
+const { login } = require('../login');
+const axios = require('axios');
+const { get, empty } = require('../../db/user');
+const MockAdapter = require('axios-mock-adapter');
+const { SSO_AUTH_URL, ACCOUNT_URL } = require('../../config');
+
+jest.mock('../../db');
+jest.mock('../../auth/getCode');
+jest.mock('inquirer', () => ({
+  prompt: () => Promise.resolve({ confirm: 'Yes' })
+}));
+jest.mock('ora', () => () => ({
+  start: () => ({
+    stop: () => {}
+  })
+}));
+
+describe('login', () => {
+  let mock;
+
+  beforeEach(() => {
+    mock = new MockAdapter(axios);
+    empty();
+  });
+
+  afterEach(() => {
+    mock.reset();
+    empty();
+  });
+
+  it('success', async () => {
+    mock.onPost(`${SSO_AUTH_URL}/api/oauth/token`).replyOnce(200, {
+      access_token: 'access_token',
+      session_id: 'session_id'
+    });
+
+    mock.onGet(`${SSO_AUTH_URL}/api/sso/current/users`).replyOnce(200, {
+      users: [
+        {
+          user_id: 'user_id'
+        }
+      ]
+    });
+
+    mock.onPost(`${ACCOUNT_URL}/api/accounts/store/token`).replyOnce(200, {
+      access_token: 'exchange_token'
+    });
+
+    console.log = jest.fn;
+    await login({
+      store: 'developer.myshoplaza.com'
+    });
+    expect(get('access_token')).toBe('access_token');
+    expect(get('session_id')).toBe('session_id');
+    expect(get('user_id')).toBe('user_id');
+    expect(get('exchange_token')).toBe('exchange_token');
+    expect(get('store_domain')).toBe('developer.myshoplaza.com');
+  });
+
+  it('failed', async () => {
+    const mockExit = jest.spyOn(process, 'exit').mockImplementation((number) => {
+      throw new Error('process.exit: ' + number);
+    });
+
+    mock.onPost(`${SSO_AUTH_URL}/api/oauth/token`).replyOnce(500, {});
+    await login({
+      store: 'developer-failed.myshoplaza.com'
+    });
+    expect(mockExit).toHaveBeenCalledWith(-1);
+
+    expect(get('access_token')).toBe(null);
+    expect(get('session_id')).toBe(null);
+    expect(get('user_id')).toBe(null);
+    expect(get('exchange_token')).toBe(null);
+    expect(get('store_domain')).toBe(null);
+  });
+});

package/lib/commands/__tests__/logout.test.js

@@ -0,0 +1,29 @@
+const logout = require('../logout');
+const { get, set, empty } = require('../../db/user');
+
+jest.mock('../../db');
+
+describe('logout', () => {
+  beforeEach(() => {
+    empty();
+  });
+
+  it('success', async () => {
+    set({
+      user_id: 'user_id',
+      session_id: 'session_id',
+      access_token: 'access_token',
+      exchange_token: 'exchange_token'
+    });
+    expect(get('access_token')).toBe('access_token');
+    expect(get('session_id')).toBe('session_id');
+    expect(get('user_id')).toBe('user_id');
+    expect(get('exchange_token')).toBe('exchange_token');
+    console.log = jest.fn;
+    logout();
+    expect(get('access_token')).toBe(null);
+    expect(get('session_id')).toBe(null);
+    expect(get('user_id')).toBe(null);
+    expect(get('exchange_token')).toBe(null);
+  });
+});

package/lib/commands/__tests__/store.test.js

@@ -0,0 +1,44 @@
+const store = require('../store');
+const chalk = require('chalk');
+const { set, empty } = require('../../db/user');
+const MockAdapter = require('axios-mock-adapter');
+const openAPI = require('../../openAPI');
+
+jest.mock('../../db');
+jest.mock('../../openAPI');
+
+describe('store', () => {
+  let mock;
+
+  beforeEach(() => {
+    set({
+      store_domain: 'developer.myshoplaza.com'
+    });
+    mock = new MockAdapter(openAPI);
+  });
+
+  afterEach(() => {
+    mock.reset();
+    empty();
+  });
+
+  it('success', async () => {
+    mock.onGet(`https://developer.myshoplaza.com/openapi/2020-07/shop`).replyOnce(200, {
+      shop: {
+        domain: 'developer.myshoplaza.com'
+      }
+    });
+    console.log = jest.fn();
+    await store();
+    expect(console.log.mock.calls[0][0]).toBe(
+      `You're currently logged into ${chalk.green('developer.myshoplaza.com')}`
+    );
+  });
+
+  it('failed', async () => {
+    mock.onGet(`https://developer.myshoplaza.com/openapi/2020-07/shop`).replyOnce(500);
+    console.log = jest.fn();
+    await store();
+    expect(console.log.mock.calls[0][0]).toBe(chalk.red(`✗ Failed to get store`));
+  });
+});

package/lib/commands/__tests__/switch.test.js

@@ -0,0 +1,45 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const switchCommand = require('../switch');
+const { get, set, empty } = require('../../db/user');
+const MockAdapter = require('axios-mock-adapter');
+const { ACCOUNT_URL } = require('../../config');
+
+jest.mock('../../db');
+
+describe('switch', () => {
+  let mock;
+
+  beforeEach(() => {
+    mock = new MockAdapter(axios);
+    empty();
+    set({ access_token: 'access_token' });
+  });
+
+  afterEach(() => {
+    mock.reset();
+    empty();
+  });
+
+  it('switch success', async () => {
+    mock.onPost(`${ACCOUNT_URL}/api/accounts/store/token`).replyOnce(200, {
+      access_token: 'exchange_token'
+    });
+    console.log = jest.fn;
+    await switchCommand({
+      store: 'developer.myshoplaza.com'
+    });
+    expect(get('access_token')).toBe('access_token');
+    expect(get('exchange_token')).toBe('exchange_token');
+  });
+
+  it('switch failed', async () => {
+    mock.onPost(`${ACCOUNT_URL}/api/accounts/store/token`).replyOnce(500, {});
+    console.log = jest.fn;
+    await switchCommand({
+      store: 'developer-failed.myshoplaza.com'
+    });
+    expect(get('access_token')).toBe(null);
+    expect(get('exchange_token')).toBe(null);
+  });
+});

package/lib/commands/login.js

@@ -0,0 +1,99 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const Sentry = require('@sentry/node');
+const ora = require('ora');
+const { get } = require('../db/user');
+const { hasBeenSetAnalytics, setAnalyticsConfig } = require('../db/analytics');
+const log = require('../log');
+const { getShopDetail } = require('../openAPI/api');
+const getCode = require('../auth/getCode');
+const { postAccessToken, getUserInfo, postExchangeToken } = require('../auth');
+let spinner;
+
+const checkAndLogin = async (store) => {
+  if (get('exchange_token')) {
+    if (get('store_domain') === store) {
+      try {
+        await getShopDetail({ ignoreLogError: true });
+        log.info(`${chalk.green('✓')} Already logged in to ${chalk.green(store)}`);
+        return;
+      } catch (err) {
+        // Ignore
+      }
+    } else {
+      try {
+        await postExchangeToken(store, { ignoreLogError: true });
+        log.info(`Logged into ${chalk.green(get('store_domain'))}`);
+        return;
+      } catch (err) {
+        // Ignore
+      }
+    }
+  }
+
+  const code = await getCode();
+  spinner = ora(`Logging in to ${chalk.green(store)}`).start();
+  await postAccessToken(code);
+  await getUserInfo();
+  await postExchangeToken(store);
+  spinner?.stop?.();
+  log.info(`${chalk.green('✓')} Finalizing authentication`);
+  log.info(`Logged into ${chalk.green(get('store_domain'))}`);
+  requestAnalyticsIfNeeded();
+};
+
+const requestAnalyticsIfNeeded = async () => {
+  const user_id = get('user_id');
+  if (hasBeenSetAnalytics(user_id)) return;
+  try {
+    const answers = await inquirer.prompt([
+      {
+        name: 'confirm',
+        type: 'list',
+        message: `Are you sure you want to enable usage reporting?`,
+        choices: ['Yes', 'No']
+      }
+    ]);
+    setAnalyticsConfig({
+      user_id,
+      enabled: answers.confirm === 'Yes' ? 1 : 0
+    });
+  } catch (error) {
+    log.error(chalk.red('✗ Failed to authenticate'));
+    Sentry.captureException(err);
+  }
+};
+
+exports.login = async (options) => {
+  try {
+    if (options.store) {
+      await checkAndLogin(options.store);
+    } else {
+      const answers = await inquirer.prompt([
+        {
+          name: 'store',
+          type: 'input',
+          message: 'The store domain (Eg: developer.myshoplaza.com)'
+        }
+      ]);
+      if (answers.store) {
+        if (!/.+\.myshoplaza\.com/.test(answers.store)) {
+          log.error(
+            chalk.red(
+              `✗ Invalid store provided ${answers.store}. Please provide the store in the following format: developer.myshoplaza.com`
+            )
+          );
+          return;
+        }
+        await checkAndLogin(answers.store);
+      } else {
+        log.error(chalk.red(`✗ Please input the store domain.`));
+        return;
+      }
+    }
+  } catch (error) {
+    spinner?.stop?.();
+    log.error(chalk.red(`✗ Failed to authenticate`));
+    Sentry.captureException(error);
+  }
+};

package/lib/commands/logout.js

@@ -0,0 +1,14 @@
+const Sentry = require('@sentry/node');
+const chalk = require('chalk');
+const { empty } = require('../db/user');
+const log = require('../log');
+
+module.exports = () => {
+  try {
+    empty();
+    log.info('Successfully logged out of your account');
+  } catch (error) {
+    log.error(chalk.red(`✗ Failed to logout`));
+    Sentry.captureException(error);
+  }
+};

package/lib/commands/store.js

@@ -0,0 +1,14 @@
+const chalk = require('chalk');
+const Sentry = require('@sentry/node');
+const { getShopDetail } = require('../openAPI/api');
+const log = require('../log');
+
+module.exports = async () => {
+  try {
+    const { data } = await getShopDetail();
+    log.info(`You're currently logged into ${chalk.green(data.shop.domain)}`);
+  } catch (error) {
+    log.error(chalk.red(`✗ Failed to get store`));
+    Sentry.captureException(error);
+  }
+};

package/lib/commands/switch.js

@@ -0,0 +1,52 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const Sentry = require('@sentry/node');
+const { get } = require('../db/user');
+const log = require('../log');
+const { postExchangeToken } = require('../auth');
+
+const switchStore = async (store) => {
+  if (!get('access_token')) {
+    log.error(chalk.red(`✗ Please login again with ${chalk.cyan('shoplazza login')}`));
+  } else {
+    try {
+      await postExchangeToken(store);
+      log.info(`Switched store to ${chalk.green(store)}`);
+    } catch (error) {
+      log.error(chalk.red(`✗ Failed to switch store`));
+      Sentry.captureException(error);
+    }
+  }
+};
+
+module.exports = async (options) => {
+  try {
+    if (options.store) {
+      return switchStore(options.store);
+    } else {
+      const answers = await inquirer.prompt([
+        {
+          name: 'store',
+          type: 'input',
+          message: 'The store domain (Eg: developer.myshoplaza.com )'
+        }
+      ]);
+      if (answers.store) {
+        if (!/.+\.myshoplaza\.com/.test(answers.store)) {
+          log.error(
+            chalk.red(
+              `✗ Invalid store provided ${answers.store}. Please provide the store in the following format: developer.myshoplaza.com`
+            )
+          );
+          process.exit(-1);
+        }
+        return switchStore(answers.store);
+      } else {
+        log.error(chalk.red(`✗ Please input the store domain.`));
+      }
+    }
+  } catch (error) {
+    log.error(chalk.red(`✗ Failed to switch store`));
+    Sentry.captureException(error);
+  }
+};

package/lib/commands/theme/__tests__/delete.test.js

@@ -0,0 +1,49 @@
+const MockAdapter = require('axios-mock-adapter');
+const chalk = require('chalk');
+const deleteCommand = require('../delete');
+const openAPI = require('../../../openAPI');
+const { set, empty } = require('../../../db/user');
+
+jest.mock('inquirer', () => ({
+  prompt: () => Promise.resolve({ confirm: 'Yes' })
+}));
+jest.mock('../../../db');
+jest.mock('../../../openAPI/index');
+
+describe('delete theme', () => {
+  let mock;
+
+  beforeEach(() => {
+    set({
+      store_domain: 'developer.myshoplaza.com'
+    });
+    mock = new MockAdapter(openAPI);
+  });
+
+  afterEach(() => {
+    mock.reset();
+    empty();
+  });
+
+  it('delete success', async () => {
+    mock.onGet(`https://developer.myshoplaza.com/openapi/2020-07/themes/theme_id`).replyOnce(200, {
+      data: { name: 'test' }
+    });
+    mock.onDelete(`https://developer.myshoplaza.com/openapi/2020-07/themes/theme_id`).replyOnce(200);
+
+    console.log = jest.fn();
+    await deleteCommand({ theme: 'theme_id' });
+    expect(console.log.mock.calls[0][0]).toBe(chalk.green(`✓ test (theme_id) theme deleted`));
+  });
+
+  it('delete failed', async () => {
+    mock.onGet(`https://developer.myshoplaza.com/openapi/2020-07/themes/theme_id`).replyOnce(200, {
+      data: { name: 'test' }
+    });
+    mock.onDelete(`https://developer.myshoplaza.com/openapi/2020-07/themes/theme_id`).replyOnce(500);
+
+    console.log = jest.fn();
+    await deleteCommand({ theme: 'theme_id' });
+    expect(console.log.mock.calls[0][0]).toBe(chalk.red(`✗ Failed to delete theme`));
+  });
+});

package/lib/commands/theme/__tests__/init.test.js

@@ -0,0 +1,21 @@
+const fs = require('fs-extra');
+const path = require('path');
+const init = require('../init');
+const execa = require('execa');
+
+jest.mock('execa', () => jest.fn());
+
+describe('theme init', () => {
+  it('clone repo', async () => {
+    jest.setTimeout(20 * 1000);
+    if (fs.existsSync(path.join(process.cwd(), 'test'))) {
+      fs.rmSync(path.join(process.cwd(), 'test'), { recursive: true });
+    }
+    expect(fs.existsSync(path.join(process.cwd(), 'test'))).toBe(false);
+    console.log = jest.fn;
+    await init({ name: 'test' });
+    expect(execa).toHaveBeenCalledWith('git', ['clone', 'https://github.com/Shoplazza/bing', 'test']);
+    expect(fs.existsSync(path.join(process.cwd(), 'test'))).toBe(true);
+    fs.rmSync(path.join(process.cwd(), 'test'), { recursive: true });
+  });
+});

package/lib/commands/theme/__tests__/list.test.js

@@ -0,0 +1,80 @@
+const chalk = require('chalk');
+const MockAdapter = require('axios-mock-adapter');
+const listCommand = require('../list');
+const openAPI = require('../../../openAPI');
+const { set, empty } = require('../../../db/user');
+
+jest.mock('ora', () => () => ({
+  start: () => ({
+    stop: () => {}
+  })
+}));
+jest.mock('../../../db');
+jest.mock('../../../openAPI/index');
+
+describe('theme list', () => {
+  let mock;
+
+  beforeEach(() => {
+    set({
+      store_domain: 'developer.myshoplaza.com'
+    });
+    mock = new MockAdapter(openAPI);
+  });
+
+  afterEach(() => {
+    mock.reset();
+    empty();
+  });
+
+  it('list info', async () => {
+    mock.onGet(`https://developer.myshoplaza.com/openapi/2020-07/themes`).replyOnce(200, {
+      data: {
+        themes: [
+          {
+            id: 'theme_id1',
+            name: 'theme1'
+          }
+        ]
+      }
+    });
+    mock.onGet(`https://developer.myshoplaza.com/openapi/2020-07/themes/default-theme`).replyOnce(200, {
+      data: {
+        id: 'theme_id',
+        name: 'default_theme'
+      }
+    });
+
+    console.log = jest.fn();
+    await listCommand();
+    expect(console.log.mock.calls[0][0]).toBe(
+      `${chalk.yellow('⭑')} List of ${chalk.green('developer.myshoplaza.com')} themes:`
+    );
+    expect(console.log.mock.calls[1][0]).toBe(
+      [
+        {
+          id: 'theme_id',
+          name: 'default_theme'
+        },
+        {
+          id: 'theme_id1',
+          name: 'theme1'
+        }
+      ].reduce(
+        (acc, theme) =>
+          (acc += `${theme.name} (${chalk.green(theme.id)}) ${
+            theme.id === 'theme_id' ? chalk.green('[live]') : chalk.yellow('[unpublished]')
+          }\n`),
+        ''
+      )
+    );
+  });
+
+  it('fetch failed', async () => {
+    mock.onGet(`https://developer.myshoplaza.com/openapi/2020-07/themes/default-theme`).replyOnce(500);
+
+    console.log = jest.fn();
+    await listCommand();
+    expect(console.log.mock.calls[0][0]).toBe(chalk.red(`✗ Failed to get theme list`));
+  });
+});

package/lib/commands/theme/__tests__/package.test.js

@@ -0,0 +1,17 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const { packageCommand } = require('../package');
+const { fstat } = require('fs');
+
+describe('theme package', () => {
+  it('zip theme', async () => {
+    process.chdir(path.join(process.cwd(), '/fixtures'));
+    console.log = jest.fn();
+    await packageCommand();
+    expect(console.log.mock.calls[0][0]).toBe(`${chalk.green('✓')} Theme packaged in TestLifeStyle-1.0.zip`);
+    expect(fs.existsSync(path.join(process.cwd(), 'TestLifeStyle-1.0.zip'))).toBe(true);
+    fs.rmSync(path.join(process.cwd(), 'TestLifeStyle-1.0.zip'));
+    process.chdir(path.join(process.cwd(), '../'));
+  });
+});