@youcan/cli 1.0.0 → 1.0.1

package/dist/cli/commands/auth/login.js

@@ -0,0 +1,105 @@
+import { createServer } from 'http';
+import { exit } from 'process';
+import prompts from 'prompts';
+import config from '../../../config/index.js';
+import openLink from '../../../utils/system/openLink.js';
+import stdout from '../../../utils/system/stdout.js';
+import { post } from '../../../utils/http.js';
+import writeToFile from '../../../utils/system/writeToFile.js';
+import messages from '../../../config/messages.js';
+import { isPortAvailable, getPidByPort } from '../../../utils/network.js';
+import { kill } from '../../../utils/system.js';
+import { LoadingSpinner } from '../../../utils/common.js';
+
+/**
+ * Spin up a local server to handle the OAuth redirect. Times out after 10 seconds.
+ * @returns A promise that resolves when the code is received.
+*/
+function captureAuthorization() {
+    return new Promise((resolve, reject) => {
+        let timeOut;
+        const server = createServer((req, res) => {
+            const { url } = req;
+            const code = (url === null || url === void 0 ? void 0 : url.split('=')[1]) || '';
+            if (!code)
+                reject(new Error('authorization code is required.'));
+            res.end('You can close this window now.');
+            clearTimeout(timeOut);
+            server.close();
+            resolve(code);
+        });
+        server.listen(config.OAUTH_CALLBACK_PORT, () => {
+            timeOut = setTimeout(() => {
+                reject(new Error('Timeout'));
+            }, config.OAUTH_CALLBACK_SERVER_TIMEOUT);
+        });
+    });
+}
+/**
+ * Exchange code for access token
+ * @param authorizationCode string
+ */
+async function exchangeAuthCode(authorizationCode) {
+    const formParams = {
+        grant_type: 'authorization_code',
+        client_id: config.OAUTH_CLIENT_ID,
+        client_secret: config.OAUTH_CLIENT_SECRET,
+        redirect_uri: config.OAUTH_CALLBACK_URL,
+        code: authorizationCode,
+    };
+    const res = await post(config.OAUTH_ACCESS_TOKEN_URL, {
+        method: 'POST',
+        body: new URLSearchParams(formParams),
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+    });
+    return res.access_token;
+}
+function command(_cli) {
+    return {
+        name: 'login',
+        group: 'auth',
+        description: 'Log into a YouCan store',
+        action: async () => {
+            if (!(await isPortAvailable(config.OAUTH_CALLBACK_PORT))) {
+                stdout.warn(`YouCan CLI requires that the port ${config.OAUTH_CALLBACK_PORT} be available`);
+                const prompt = await prompts({
+                    initial: false,
+                    type: 'confirm',
+                    name: 'terminate',
+                    message: 'Terminate the process to free the port?',
+                });
+                if (!prompt.terminate) {
+                    stdout.log('Exiting..');
+                    exit(1);
+                }
+                const pid = await getPidByPort(config.OAUTH_CALLBACK_PORT);
+                if (pid) {
+                    await LoadingSpinner.exec(`Terminating process ${pid}..`, async (spinner) => {
+                        try {
+                            await kill(pid, 'SIGTERM', 30000);
+                        }
+                        catch (err) {
+                            spinner.error('Could not terminate process, proceeding..');
+                        }
+                    });
+                }
+            }
+            try {
+                openLink(config.OAUTH_AUTH_CODE_URL);
+            }
+            catch (err) {
+                stdout.log(messages.LOGIN_OPEN_LINK);
+                stdout.info(config.OAUTH_AUTH_CODE_URL);
+            }
+            await LoadingSpinner.exec('Authenticating..', async () => {
+                const authorization = await captureAuthorization();
+                writeToFile(config.CLI_GLOBAL_CONFIG_PATH, JSON.stringify({ access_token: await exchangeAuthCode(authorization) }));
+            });
+            stdout.info(messages.LOGIN_SUCCESS);
+        },
+    };
+}
+
+export { command as default };

package/dist/cli/commands/auth/logout.js

@@ -0,0 +1,20 @@
+import config from '../../../config/index.js';
+import messages from '../../../config/messages.js';
+import deleteFile from '../../../utils/system/deleteFile.js';
+import stdout from '../../../utils/system/stdout.js';
+
+function command(cli) {
+    return {
+        name: 'logout',
+        group: 'auth',
+        description: 'Log out from the current store',
+        action: async () => {
+            if (!cli.client.isAuthenticated())
+                return stdout.error(messages.AUTH_USER_NOT_LOGGED_IN);
+            deleteFile(config.CLI_GLOBAL_CONFIG_PATH);
+            stdout.info(messages.AUTH_USER_LOGGED_OUT);
+        },
+    };
+}
+
+export { command as default };

package/dist/cli/commands/index.js

@@ -0,0 +1,8 @@
+export { default as LoginCommand } from './auth/login.js';
+export { default as LogoutCommand } from './auth/logout.js';
+export { default as InitCommand } from './theme/init.js';
+export { default as DevCommand } from './theme/dev.js';
+export { default as DeleteCommand } from './theme/delete.js';
+export { default as PullCommand } from './theme/pull.js';
+
+//  auth

package/dist/cli/commands/theme/delete.js

@@ -0,0 +1,43 @@
+import prompts from 'prompts';
+import messages from '../../../config/messages.js';
+import stdout from '../../../utils/system/stdout.js';
+import { LoadingSpinner } from '../../../utils/common.js';
+
+function command(cli) {
+    return {
+        name: 'delete',
+        group: 'theme',
+        description: 'Delete a remote development theme',
+        options: [],
+        action: async () => {
+            if (!cli.client.isAuthenticated())
+                return stdout.error(messages.AUTH_USER_NOT_LOGGED_IN);
+            const { dev: devThemes } = await cli.client.listThemes();
+            if (!devThemes.length)
+                return stdout.error(messages.DELETE_NO_REMOTE_THEMES);
+            const choices = devThemes.map(theme => ({
+                title: theme.name,
+                value: theme.id,
+            }));
+            const { themeId } = await prompts({
+                type: 'select',
+                name: 'themeId',
+                message: messages.DELETE_SELECT_THEME,
+                choices,
+            });
+            if (!themeId)
+                return stdout.error(messages.DELETE_NO_THEME_SELECTED);
+            await LoadingSpinner.exec(`${messages.DELETE_IN_PROGRESS} ${themeId}..`, async (spinner) => {
+                try {
+                    await cli.client.deleteTheme(themeId);
+                }
+                catch (err) {
+                    spinner.error(messages.DELETE_ERROR);
+                }
+            });
+            stdout.info(messages.DELETE_THEME_DELETED);
+        },
+    };
+}
+
+export { command as default };

package/dist/cli/commands/theme/dev.js

@@ -0,0 +1,190 @@
+import { cwd } from 'process';
+import { clear } from 'console';
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import crypto from 'crypto';
+import chokidar from 'chokidar';
+import kleur from 'kleur';
+import { fileFromPathSync } from 'formdata-node/file-from-path';
+import io from 'socket.io-client';
+import stdout from '../../../utils/system/stdout.js';
+import { getCurrentThemeId, LoadingSpinner } from '../../../utils/common.js';
+import config from '../../../config/index.js';
+import previewTheme from '../../../core/themes/preview.js';
+import messages from '../../../config/messages.js';
+
+const sizeFormatter = Intl.NumberFormat('en', {
+    notation: 'compact',
+    style: 'unit',
+    unit: 'byte',
+    unitDisplay: 'narrow',
+});
+const eventLogTagMap = {
+    error: () => kleur.bold().red('[error]'),
+    add: () => kleur.bold().green('[created]'),
+    change: () => kleur.bold().blue('[updated]'),
+    unlink: () => kleur.bold().yellow('[deleted]'),
+};
+function logFileEvent(options) {
+    const tag = eventLogTagMap[options.event]();
+    return stdout.log(`${tag} ${kleur.underline().white(options.path)} - ${sizeFormatter.format(options.size)} | ${options.roundtrip}ms \n`);
+}
+function connectPreviewServer() {
+    const socket = io(`ws://localhost:${config.PREVIEW_SERVER_PORT}`);
+    socket.on('connect', () => {
+        stdout.log(messages.DEV_PREVIEW_SERVER_CONNECTED);
+    });
+    return socket;
+}
+async function syncChanges(cli, themeId) {
+    const meta = await cli.client.getThemeMeta(themeId);
+    for (const fileType of config.THEME_FILE_TYPES) {
+        const files = meta[fileType];
+        const dirFiles = readdirSync(`./${fileType}`);
+        // save schema before data
+        if (fileType === 'config') {
+            const fileOrder = ['settings_schema.json', 'settings_data.json'];
+            files.sort((a, b) => fileOrder.indexOf(a.file_name) - fileOrder.indexOf(b.file_name));
+        }
+        // add newly created files
+        if (dirFiles.length > 0) {
+            const newFiles = dirFiles.filter(file => !files.find(f => f.file_name === file));
+            for (const file of newFiles) {
+                try {
+                    const fileData = fileFromPathSync(`./${fileType}/${file}`);
+                    await cli.client.updateFile(themeId, {
+                        file_type: fileType,
+                        file_name: file,
+                        file_operation: 'save',
+                        file_content: fileData,
+                    });
+                }
+                catch (err) {
+                    if (err instanceof Error)
+                        stdout.error(`[error] ${file}: ${err.message}`);
+                }
+            }
+        }
+        // update remote with local changes
+        for (const file of files) {
+            const filePath = `${file.type}/${file.file_name}`;
+            if (!existsSync(filePath)) {
+                try {
+                    await cli.client.deleteFile(themeId, {
+                        file_type: file.type,
+                        file_name: file.file_name,
+                        file_operation: 'delete',
+                    });
+                }
+                catch (err) {
+                    if (err instanceof Error)
+                        stdout.error(`[error] ${file.file_name}: ${err.message}`);
+                }
+                continue;
+            }
+            const fileStream = readFileSync(filePath);
+            const localHash = crypto.createHash('sha1');
+            localHash.update(fileStream);
+            if (localHash.digest('hex') !== file.hash) {
+                try {
+                    await cli.client.updateFile(themeId, {
+                        file_type: file.type,
+                        file_name: file.file_name,
+                        file_operation: 'save',
+                        file_content: fileFromPathSync(filePath),
+                    });
+                }
+                catch (err) {
+                    if (err instanceof Error)
+                        stdout.error(`[error] ${file.file_name}: ${err.message}`);
+                }
+            }
+        }
+    }
+}
+function command(cli) {
+    return {
+        name: 'dev',
+        group: 'theme',
+        description: 'starts a dev server and watches over the current directory',
+        options: [
+            { name: '-p, --preview', description: 'opens a preview window' },
+        ],
+        action: async (options) => {
+            let socket;
+            if (!cli.client.isAuthenticated())
+                return stdout.error(messages.AUTH_USER_NOT_LOGGED_IN);
+            const themeId = await getCurrentThemeId(cwd());
+            if (!themeId)
+                return stdout.error(messages.DEV_NO_THEME_DETECTED);
+            const { domain } = await cli.client.getStoreInfo();
+            clear();
+            const loadingSpinner = new LoadingSpinner('Syncing changes...');
+            loadingSpinner.start();
+            await syncChanges(cli, themeId);
+            loadingSpinner.stop();
+            if (options.preview) {
+                socket = connectPreviewServer();
+                socket.emit('theme:dev', { themeId });
+                previewTheme(`https://${domain}/themes/${themeId}/preview`);
+            }
+            stdout.info(`Watching for changes in ${kleur.bold().white(cwd())}...`);
+            chokidar
+                .watch(config.THEME_FILE_TYPES, {
+                persistent: true,
+                ignoreInitial: true,
+                awaitWriteFinish: {
+                    stabilityThreshold: 50,
+                },
+            })
+                .on('all', async (event, path, stats) => {
+                var _a, _b;
+                const start = new Date().getTime();
+                try {
+                    const [filetype, filename] = path.split('/', 2);
+                    if (!config.THEME_FILE_TYPES.includes(filetype))
+                        return;
+                    if (!['add', 'change', 'unlink'].includes(event))
+                        return;
+                    switch (event) {
+                        case 'add':
+                        case 'change':
+                            await cli.client.updateFile(themeId, {
+                                file_type: filetype,
+                                file_name: filename,
+                                file_operation: 'save',
+                                file_content: fileFromPathSync(path),
+                            });
+                            break;
+                        case 'unlink':
+                            await cli.client.deleteFile(themeId, {
+                                file_type: filetype,
+                                file_name: filename,
+                                file_operation: 'delete',
+                            });
+                            break;
+                    }
+                    if (socket)
+                        socket.emit('theme:update', { themeId });
+                    logFileEvent({
+                        path,
+                        event,
+                        size: (_a = stats === null || stats === void 0 ? void 0 : stats.size) !== null && _a !== void 0 ? _a : 0,
+                        roundtrip: new Date().getTime() - start,
+                    });
+                }
+                catch (err) {
+                    logFileEvent({
+                        path,
+                        event: 'error',
+                        size: (_b = stats === null || stats === void 0 ? void 0 : stats.size) !== null && _b !== void 0 ? _b : 0,
+                        roundtrip: new Date().getTime() - start,
+                    });
+                    if (err instanceof Error)
+                        stdout.info(`message: ${err.message}`);
+                }
+            });
+        },
+    };
+}
+
+export { command as default };

package/dist/cli/commands/theme/init.js

@@ -0,0 +1,85 @@
+import { cwd } from 'process';
+import path from 'path';
+import prompts from 'prompts';
+import { fileFromPath } from 'formdata-node/file-from-path';
+import config from '../../../config/index.js';
+import cloneRepository from '../../../utils/git/cloneRepository.js';
+import stdout from '../../../utils/system/stdout.js';
+import zipFolder from '../../../utils/system/zipFolder.js';
+import writeToFile from '../../../utils/system/writeToFile.js';
+import deleteFile from '../../../utils/system/deleteFile.js';
+import messages from '../../../config/messages.js';
+
+const inquiries = [
+    {
+        type: 'text',
+        name: 'theme_name',
+        message: 'The theme\'s name, used for display purposes.',
+        initial: 'Starter',
+    },
+    {
+        type: 'text',
+        name: 'theme_author',
+        message: 'The theme\'s author',
+        initial: 'YouCan',
+    },
+    {
+        type: 'text',
+        name: 'theme_version',
+        message: 'The theme\'s current version',
+        initial: '1.0.0',
+    },
+    {
+        type: 'text',
+        name: 'theme_support_url',
+        message: 'A support URL for this theme.',
+        initial: 'https://developer.youcan.shop',
+    },
+    {
+        type: 'text',
+        name: 'theme_documentation_url',
+        message: 'A documentation URL for this theme.',
+        initial: 'https://developer.youcan.shop',
+    },
+];
+const defaultInquiries = {
+    theme_name: 'Starter',
+    theme_author: 'YouCan',
+    theme_version: '1.0.0',
+    theme_support_url: 'https://developer.youcan.shop',
+    theme_documentation_url: 'https://developer.youcan.shop',
+};
+function getSelectedTheme(optionTheme) {
+    var _a;
+    const selectedTheme = (_a = config.AVAILABLE_THEMES.find(theme => theme.name === (optionTheme === null || optionTheme === void 0 ? void 0 : optionTheme.toLocaleLowerCase().trim()))) === null || _a === void 0 ? void 0 : _a.repository;
+    if (selectedTheme)
+        return selectedTheme;
+    return config.STARTER_THEME_GIT_REPOSITORY;
+}
+function command(cli) {
+    return {
+        name: 'init',
+        group: 'theme',
+        description: 'Create a new theme or clone existing one.',
+        options: [
+            { name: '-t, --theme <theme>', description: 'Specify a theme name e.g. cod-theme' },
+            { name: '-d, --default', description: 'Use default values for theme name, author, version, support url and documentation url.' },
+        ],
+        action: async (options) => {
+            if (!cli.client.isAuthenticated())
+                return stdout.error(messages.AUTH_USER_NOT_LOGGED_IN);
+            const info = options.default ? defaultInquiries : await prompts(inquiries);
+            stdout.info(messages.INIT_CLONE_START);
+            const themeRepository = getSelectedTheme(options.theme);
+            cloneRepository(themeRepository, info.theme_name);
+            const zippedTheme = await zipFolder(cwd(), info.theme_name);
+            const themeFolderRs = await fileFromPath(zippedTheme);
+            const id = await cli.client.initTheme({ ...info, archive: themeFolderRs });
+            writeToFile(path.resolve(cwd(), info.theme_name, '.youcan'), JSON.stringify({ theme_id: id }));
+            deleteFile(zippedTheme);
+            stdout.info(`${messages.INIT_SUCCESS}${id}`);
+        },
+    };
+}
+
+export { command as default };

package/dist/cli/commands/theme/pull.js

@@ -0,0 +1,54 @@
+import { cwd } from 'process';
+import prompts from 'prompts';
+import decompress from 'decompress';
+import stdout from '../../../utils/system/stdout.js';
+import { saveHttpFile } from '../../../utils/system/saveFile.js';
+import { getCurrentThemeId } from '../../../utils/common.js';
+import writeToFile from '../../../utils/system/writeToFile.js';
+import deleteFile from '../../../utils/system/deleteFile.js';
+import messages from '../../../config/messages.js';
+
+function command(cli) {
+    return {
+        name: 'pull',
+        group: 'theme',
+        description: 'Pull a theme',
+        options: [],
+        action: async () => {
+            if (!cli.client.isAuthenticated())
+                return stdout.error(messages.AUTH_USER_NOT_LOGGED_IN);
+            const { dev } = await cli.client.listThemes();
+            const choices = dev.map(theme => ({
+                title: theme.name,
+                value: theme.id,
+            }));
+            let themeId;
+            const cwdThemeId = await getCurrentThemeId(cwd());
+            if (!cwdThemeId) {
+                const promt = await prompts({
+                    type: 'select',
+                    name: 'themeId',
+                    message: 'Select a theme to pull',
+                    choices,
+                });
+                themeId = promt.themeId;
+            }
+            themeId = themeId || cwdThemeId;
+            if (!themeId)
+                return stdout.error(messages.PULL_NO_THEME_FOUND);
+            const fileName = `${themeId}`;
+            const fileNameZip = `${fileName}.zip`;
+            stdout.info(messages.PULL_PULLING_THEME);
+            const response = await cli.client.pullTheme(themeId);
+            await saveHttpFile(response, fileNameZip);
+            stdout.info(messages.PULL_UNPACKING_THEME);
+            const unpackingFolder = cwdThemeId ? cwd() : `${cwd()}/${fileName}`;
+            await decompress(fileNameZip, unpackingFolder);
+            deleteFile(fileNameZip);
+            writeToFile(`${unpackingFolder}/.youcan`, JSON.stringify({ theme_id: themeId }));
+            stdout.info(`${messages.PULL_THEME_PULLED} ${fileName}`);
+        },
+    };
+}
+
+export { command as default };

package/dist/cli/index.js

@@ -0,0 +1,51 @@
+import { existsSync, promises } from 'fs';
+import { cac } from 'cac';
+import * as index from './commands/index.js';
+import Client from '../core/client/client.js';
+import config from '../config/index.js';
+
+const cli = {
+    client: new Client(),
+    handler: cac('youcan'),
+    registerCommand(command) {
+        var _a, _b;
+        const definition = command(this);
+        const instance = this.handler
+            .command(definition.name, definition.description)
+            .action(definition.action);
+        (_a = definition.aliases) === null || _a === void 0 ? void 0 : _a.forEach(a => instance.alias(a));
+        (_b = definition.options) === null || _b === void 0 ? void 0 : _b.forEach(o => instance.option(o.name, o.description, o.config));
+    },
+    getAvailableCommands() {
+        return Object.values(index);
+    },
+    async init() {
+        await this.prepareClient();
+        Object.values(index).forEach(command => this.registerCommand(command));
+        this.handler.on('command:*', () => {
+            this.handler.outputHelp();
+        });
+        this.handler.help();
+        this.handler.parse();
+    },
+    async prepareClient() {
+        if (!existsSync(config.CLI_GLOBAL_CONFIG_DIR))
+            await promises.mkdir(config.CLI_GLOBAL_CONFIG_DIR);
+        if (!existsSync(config.CLI_GLOBAL_CONFIG_PATH))
+            return await promises.writeFile(config.CLI_GLOBAL_CONFIG_PATH, '', { flag: 'wx', encoding: 'utf-8' });
+        const data = await promises
+            .readFile(config.CLI_GLOBAL_CONFIG_PATH, 'utf-8')
+            .then((b) => {
+            try {
+                return JSON.parse(b);
+            }
+            catch (_a) {
+                return {};
+            }
+        });
+        if ('access_token' in data)
+            this.client.setAccessToken(data.access_token);
+    },
+};
+
+export { cli as default };

package/dist/config/index.js

@@ -0,0 +1,25 @@
+import { homedir } from 'os';
+import path from 'path';
+
+var config = {
+    OAUTH_CLIENT_ID: 8,
+    OAUTH_CALLBACK_PORT: 3000,
+    OAUTH_CALLBACK_SERVER_TIMEOUT: 5 * 60 * 100,
+    OAUTH_CALLBACK_URL: 'http://localhost:3000/',
+    OAUTH_CLIENT_SECRET: 'lvUw2mQ7nXp4WqZ9CZlURMgRGAra3KuOrYhFlU7X',
+    OAUTH_AUTH_CODE_URL: 'https://seller-area.youcan.shop/admin/oauth/authorize?response_type=code&client_id=8&redirect_url=http://localhost:3000/&state=',
+    OAUTH_ACCESS_TOKEN_URL: 'https://seller-area.youcan.shop/admin/oauth/token',
+    SELLER_AREA_API_BASE_URI: 'https://api.youcan.shop',
+    SELLER_AREA_WEB_BASE_URI: 'https://seller-area.youcan.shop',
+    STARTER_THEME_GIT_REPOSITORY: 'git@github.com:youcan-shop/light-theme.git',
+    AVAILABLE_THEMES: [
+        { name: 'default', repository: 'git@github.com:youcan-shop/light-theme.git' },
+        { name: 'cod-theme', repository: 'git@github.com:youcan-shop/cod-theme.git' },
+    ],
+    CLI_GLOBAL_CONFIG_DIR: path.resolve(homedir(), '.youcan'),
+    CLI_GLOBAL_CONFIG_PATH: path.resolve(homedir(), '.youcan', 'config.json'),
+    THEME_FILE_TYPES: ['layouts', 'sections', 'locales', 'assets', 'snippets', 'config', 'templates'],
+    PREVIEW_SERVER_PORT: 7565,
+};
+
+export { config as default };

package/dist/config/messages.js

@@ -0,0 +1,26 @@
+var messages = {
+    LOGIN_OPEN_LINK: 'Open this link in your browser to continue authentication:',
+    LOGIN_SUCCESS: 'You have been successfully logged in.',
+    INIT_SUCCESS: 'The theme has been initiated with id: ',
+    INIT_CLONE_START: 'Cloning your theme from github',
+    AUTH_USER_NOT_LOGGED_IN: 'You are not currently logged into any store.',
+    AUTH_USER_LOGGED_OUT: 'You have been successfully logged out.',
+    DELETE_NO_THEME_SELECTED: 'No theme selected.',
+    DELETE_THEME_DELETED: 'Theme deleted successfully.',
+    DELETE_NO_REMOTE_THEMES: 'This store does not have any development themes.',
+    DELETE_SELECT_THEME: 'Which remote development theme would you like to delete?',
+    DELETE_IN_PROGRESS: 'Deleting theme',
+    DELETE_ERROR: 'Could not delete remote development theme.',
+    DEV_PREVIEW_SERVER_CONNECTED: 'Connected to preview server',
+    DEV_WATCHING_FILES: 'Watching theme files for changes...',
+    DEV_NO_THEME_DETECTED: 'No theme detected in the current directory.',
+    PULL_NO_THEME_FOUND: 'No theme found',
+    PULL_PULLING_THEME: 'Pulling your theme...',
+    PULL_UNPACKING_THEME: 'Unpacking...',
+    PULL_THEME_PULLED: 'Theme has been pulled to ',
+    PREVIEW_BROWSER_CLOSED: 'Browser closed',
+    PREVIEW_THEME_UPDATED: 'Theme change detected, reloading...',
+    PREVIEW_RELOADED: 'Reloaded in ',
+};
+
+export { messages as default };